From fe0c22c78912c043be64bdf86c9e1e3d38b18474 Mon Sep 17 00:00:00 2001 From: Tim Wojtulewicz Date: Fri, 21 Aug 2020 09:29:37 -0700 Subject: [PATCH] Base: Clean up explicit uses of namespaces in places where they're not necessary. This commit covers all of the common and base classes. --- src/Anon.cc | 56 +- src/Attr.cc | 8 +- src/Attr.h | 12 +- src/Base64.cc | 30 +- src/Base64.h | 4 +- src/BifReturnVal.cc | 4 +- src/BifReturnVal.h | 10 +- src/CCL.cc | 2 +- src/CompHash.cc | 344 +++++----- src/CompHash.h | 30 +- src/Conn.cc | 200 +++--- src/Conn.h | 112 ++-- src/DFA.cc | 8 +- src/DFA.h | 4 +- src/DNS_Mgr.cc | 192 +++--- src/DNS_Mgr.h | 50 +- src/DbgBreakpoint.cc | 28 +- src/DbgBreakpoint.h | 6 +- src/DbgWatch.cc | 12 +- src/DbgWatch.h | 8 +- src/Debug.cc | 114 ++-- src/Debug.h | 38 +- src/DebugCmdInfoConstants.cc | 150 ++--- src/DebugCmds.cc | 58 +- src/DebugCmds.h | 2 +- src/DebugLogger.cc | 18 +- src/DebugLogger.h | 2 +- src/Desc.cc | 30 +- src/Desc.h | 50 +- src/Dict.cc | 50 +- src/Dict.h | 46 +- src/Discard.cc | 28 +- src/Discard.h | 14 +- src/EquivClass.cc | 2 +- src/Event.cc | 54 +- src/Event.h | 48 +- src/EventHandler.cc | 36 +- src/EventHandler.h | 18 +- src/EventRegistry.cc | 28 +- src/EventRegistry.h | 10 +- src/Expr.cc | 816 ++++++++++++------------ src/Expr.h | 42 +- src/File.cc | 58 +- src/File.h | 20 +- src/Flare.cc | 10 +- src/Frag.cc | 36 +- src/Frag.h | 16 +- src/Frame.cc | 48 +- src/Frame.h | 52 +- src/Func.cc | 176 ++--- src/Func.h | 94 +-- src/Hash.cc | 6 +- src/Hash.h | 11 +- src/ID.cc | 122 ++-- src/ID.h | 51 +- src/IP.cc | 362 +++++------ src/IP.h | 42 +- src/IPAddr.cc | 36 +- src/IPAddr.h | 10 +- src/IntrusivePtr.h | 6 +- src/List.h | 12 +- src/NFA.h | 6 +- src/NetVar.cc | 139 ++-- src/Notifier.cc | 12 +- src/Obj.cc | 58 +- src/Obj.h | 10 +- src/OpaqueVal.cc | 120 ++-- src/OpaqueVal.h | 58 +- src/Options.cc | 32 +- src/Options.h | 4 +- src/PacketDumper.cc | 6 +- src/PacketFilter.cc | 30 +- src/PacketFilter.h | 20 +- src/Pipe.cc | 8 +- src/PolicyFile.cc | 26 +- src/PrefixTable.cc | 55 +- src/PrefixTable.h | 20 +- src/PriorityQueue.cc | 2 +- src/RE.cc | 34 +- src/RE.h | 28 +- src/Reassem.cc | 2 +- src/Reassem.h | 4 +- src/Reporter.cc | 112 ++-- src/Reporter.h | 38 +- src/Rule.cc | 4 +- src/Rule.h | 20 +- src/RuleAction.cc | 32 +- src/RuleAction.h | 8 +- src/RuleCondition.cc | 32 +- src/RuleCondition.h | 2 +- src/RuleMatcher.cc | 197 +++--- src/RuleMatcher.h | 48 +- src/RunState.cc | 106 +-- src/Scope.cc | 70 +- src/Scope.h | 51 +- src/ScriptCoverageManager.cc | 26 +- src/ScriptCoverageManager.h | 4 +- src/SerializationFormat.cc | 60 +- src/SerializationFormat.h | 16 +- src/Sessions.cc | 192 +++--- src/Sessions.h | 74 +-- src/SmithWaterman.cc | 68 +- src/SmithWaterman.h | 25 +- src/Stats.cc | 182 +++--- src/Stats.h | 22 +- src/Stmt.cc | 74 +-- src/Stmt.h | 12 +- src/Tag.cc | 20 +- src/Tag.h | 22 +- src/Timer.cc | 32 +- src/Timer.h | 6 +- src/Traverse.cc | 6 +- src/Traverse.h | 26 +- src/Trigger.cc | 86 +-- src/Trigger.h | 26 +- src/TunnelEncapsulation.cc | 18 +- src/TunnelEncapsulation.h | 22 +- src/Type.cc | 260 ++++---- src/Type.h | 116 ++-- src/UID.cc | 6 +- src/Val.cc | 312 ++++----- src/Val.h | 284 ++++----- src/Var.cc | 348 +++++----- src/Var.h | 48 +- src/WeirdState.cc | 4 +- src/ZeekArgs.cc | 18 +- src/ZeekString.cc | 14 +- src/ZeekString.h | 4 +- src/analyzer/Analyzer.cc | 92 ++- src/analyzer/Analyzer.h | 34 +- src/analyzer/Component.cc | 8 +- src/analyzer/Component.h | 2 +- src/analyzer/Manager.cc | 106 +-- src/analyzer/Manager.h | 18 +- src/analyzer/Tag.cc | 24 +- src/analyzer/Tag.h | 12 +- src/broker/Data.cc | 338 +++++----- src/broker/Data.h | 52 +- src/broker/Manager.cc | 406 ++++++------ src/broker/Manager.h | 38 +- src/broker/Store.cc | 10 +- src/broker/Store.h | 32 +- src/digest.cc | 8 +- src/file_analysis/Analyzer.cc | 20 +- src/file_analysis/Analyzer.h | 16 +- src/file_analysis/AnalyzerSet.cc | 42 +- src/file_analysis/AnalyzerSet.h | 22 +- src/file_analysis/Component.cc | 10 +- src/file_analysis/Component.h | 12 +- src/file_analysis/File.cc | 204 +++--- src/file_analysis/File.h | 50 +- src/file_analysis/FileReassembler.cc | 4 +- src/file_analysis/FileReassembler.h | 4 +- src/file_analysis/FileTimer.cc | 4 +- src/file_analysis/Manager.cc | 120 ++-- src/file_analysis/Manager.h | 52 +- src/file_analysis/Tag.cc | 10 +- src/file_analysis/Tag.h | 12 +- src/fuzzers/FuzzBuffer.cc | 10 +- src/fuzzers/FuzzBuffer.h | 4 +- src/fuzzers/fuzzer-setup.h | 4 +- src/input.h | 2 +- src/input/Component.cc | 4 +- src/input/Component.h | 6 +- src/input/Manager.cc | 766 +++++++++++----------- src/input/Manager.h | 36 +- src/input/ReaderBackend.cc | 2 +- src/input/ReaderBackend.h | 8 +- src/input/ReaderFrontend.cc | 8 +- src/input/ReaderFrontend.h | 4 +- src/input/Tag.cc | 10 +- src/input/Tag.h | 12 +- src/iosource/Component.cc | 22 +- src/iosource/Component.h | 12 +- src/iosource/Manager.cc | 36 +- src/iosource/Packet.cc | 42 +- src/iosource/Packet.h | 14 +- src/iosource/PktDumper.cc | 6 +- src/iosource/PktDumper.h | 2 +- src/iosource/PktSrc.cc | 66 +- src/iosource/PktSrc.h | 12 +- src/iosource/pcap/Dumper.cc | 12 +- src/iosource/pcap/Dumper.h | 2 +- src/iosource/pcap/Plugin.cc | 16 +- src/iosource/pcap/Source.cc | 30 +- src/iosource/pcap/Source.h | 4 +- src/legacy-netvar-init.cc | 136 ++-- src/logging/Component.cc | 4 +- src/logging/Component.h | 6 +- src/logging/Manager.cc | 422 ++++++------ src/logging/Manager.h | 54 +- src/logging/Tag.cc | 10 +- src/logging/Tag.h | 12 +- src/logging/WriterBackend.cc | 12 +- src/logging/WriterBackend.h | 10 +- src/logging/WriterFrontend.cc | 36 +- src/logging/WriterFrontend.h | 8 +- src/make_dbg_constants.py | 11 +- src/net_util.cc | 14 +- src/net_util.h | 10 +- src/plugin/Component.cc | 8 +- src/plugin/Component.h | 4 +- src/plugin/ComponentManager.h | 20 +- src/plugin/Manager.cc | 221 +++---- src/plugin/Manager.h | 20 +- src/plugin/Plugin.cc | 50 +- src/plugin/Plugin.h | 48 +- src/probabilistic/BloomFilter.cc | 12 +- src/probabilistic/CardinalityCounter.cc | 4 +- src/probabilistic/Hasher.cc | 8 +- src/probabilistic/Topk.cc | 36 +- src/probabilistic/Topk.h | 18 +- src/supervisor/Supervisor.cc | 216 +++---- src/supervisor/Supervisor.h | 24 +- src/threading/BasicThread.cc | 26 +- src/threading/Formatter.h | 21 +- src/threading/Manager.cc | 42 +- src/threading/Manager.h | 2 +- src/threading/MsgThread.cc | 52 +- src/threading/MsgThread.h | 8 +- src/threading/Queue.h | 4 +- src/threading/SerialTypes.cc | 264 ++++---- src/threading/SerialTypes.h | 28 +- src/threading/formatters/Ascii.cc | 110 ++-- src/threading/formatters/Ascii.h | 14 +- src/threading/formatters/JSON.cc | 48 +- src/threading/formatters/JSON.h | 16 +- src/util.cc | 130 ++-- src/util.h | 8 +- src/zeek-setup.cc | 344 +++++----- src/zeek-setup.h | 4 +- src/zeekygen/Configuration.cc | 18 +- src/zeekygen/IdentifierInfo.cc | 8 +- src/zeekygen/IdentifierInfo.h | 8 +- src/zeekygen/Manager.cc | 100 +-- src/zeekygen/Manager.h | 8 +- src/zeekygen/PackageInfo.cc | 16 +- src/zeekygen/ScriptInfo.cc | 50 +- src/zeekygen/Target.cc | 156 ++--- src/zeekygen/utils.cc | 8 +- 240 files changed, 6823 insertions(+), 6787 deletions(-) diff --git a/src/Anon.cc b/src/Anon.cc index d2365e46ca..c0c32623a6 100644 --- a/src/Anon.cc +++ b/src/Anon.cc @@ -13,14 +13,15 @@ #include "Scope.h" #include "ID.h" #include "IPAddr.h" +#include "Event.h" -using namespace zeek::detail; +namespace zeek::detail { -AnonymizeIPAddr* zeek::detail::ip_anonymizer[NUM_ADDR_ANONYMIZATION_METHODS] = {nullptr}; +AnonymizeIPAddr* ip_anonymizer[NUM_ADDR_ANONYMIZATION_METHODS] = {nullptr}; static uint32_t rand32() { - return ((zeek::util::detail::random_number() & 0xffff) << 16) | (zeek::util::detail::random_number() & 0xffff); + return ((util::detail::random_number() & 0xffff) << 16) | (util::detail::random_number() & 0xffff); } // From tcpdpriv. @@ -75,7 +76,7 @@ ipaddr32_t AnonymizeIPAddr::Anonymize(ipaddr32_t addr) // Keep the specified prefix unchanged. bool AnonymizeIPAddr::PreservePrefix(ipaddr32_t /* input */, int /* num_bits */) { - zeek::reporter->InternalError("prefix preserving is not supported for the anonymizer"); + reporter->InternalError("prefix preserving is not supported for the anonymizer"); return false; } @@ -104,7 +105,7 @@ ipaddr32_t AnonymizeIPAddr_RandomMD5::anonymize(ipaddr32_t input) uint8_t digest[16]; ipaddr32_t output = 0; - zeek::util::detail::hmac_md5(sizeof(input), (u_char*)(&input), digest); + util::detail::hmac_md5(sizeof(input), (u_char*)(&input), digest); for ( int i = 0; i < 4; ++i ) output = (output << 8) | digest[i]; @@ -132,7 +133,7 @@ ipaddr32_t AnonymizeIPAddr_PrefixMD5::anonymize(ipaddr32_t input) prefix.prefix = htonl((input & ~(prefix_mask>>i)) | (1<<(31-i))); // HK(PAD(x_0 ... x_{i-1})). - zeek::util::detail::hmac_md5(sizeof(prefix), (u_char*) &prefix, digest); + util::detail::hmac_md5(sizeof(prefix), (u_char*) &prefix, digest); // f_{i-1} = LSB(HK(PAD(x_0 ... x_{i-1}))). ipaddr32_t bit_mask = (digest[0] & 1) << (31-i); @@ -172,7 +173,7 @@ bool AnonymizeIPAddr_A50::PreservePrefix(ipaddr32_t input, int num_bits) if ( ! before_anonymization ) { - zeek::reporter->Error("prefix perservation specified after anonymization begun"); + reporter->Error("prefix perservation specified after anonymization begun"); return false; } @@ -219,7 +220,7 @@ AnonymizeIPAddr_A50::Node* AnonymizeIPAddr_A50::new_node_block() int block_size = 1024; Node* block = new Node[block_size]; if ( ! block ) - zeek::reporter->InternalError("out of memory!"); + reporter->InternalError("out of memory!"); blocks.push_back(block); @@ -271,7 +272,7 @@ ipaddr32_t AnonymizeIPAddr_A50::make_output(ipaddr32_t old_output, int swivel) c AnonymizeIPAddr_A50::Node* AnonymizeIPAddr_A50::make_peer(ipaddr32_t a, Node* n) { if ( a == 0 || a == 0xFFFFFFFFU ) - zeek::reporter->InternalError("0.0.0.0 and 255.255.255.255 should never get into the tree"); + reporter->InternalError("0.0.0.0 and 255.255.255.255 should never get into the tree"); // Become a peer. // Algorithm: create two nodes, the two peers. Leave orig node as @@ -354,15 +355,15 @@ AnonymizeIPAddr_A50::Node* AnonymizeIPAddr_A50::find_node(ipaddr32_t a) } } - zeek::reporter->InternalError("out of memory!"); + reporter->InternalError("out of memory!"); return nullptr; } -static zeek::TableValPtr anon_preserve_orig_addr; -static zeek::TableValPtr anon_preserve_resp_addr; -static zeek::TableValPtr anon_preserve_other_addr; +static TableValPtr anon_preserve_orig_addr; +static TableValPtr anon_preserve_resp_addr; +static TableValPtr anon_preserve_other_addr; -void zeek::detail::init_ip_addr_anonymizers() +void init_ip_addr_anonymizers() { ip_anonymizer[KEEP_ORIG_ADDR] = nullptr; ip_anonymizer[SEQUENTIALLY_NUMBERED] = new AnonymizeIPAddr_Seq(); @@ -373,23 +374,23 @@ void zeek::detail::init_ip_addr_anonymizers() auto id = global_scope()->Find("preserve_orig_addr"); if ( id ) - anon_preserve_orig_addr = zeek::cast_intrusive(id->GetVal()); + anon_preserve_orig_addr = cast_intrusive(id->GetVal()); id = global_scope()->Find("preserve_resp_addr"); if ( id ) - anon_preserve_resp_addr = zeek::cast_intrusive(id->GetVal()); + anon_preserve_resp_addr = cast_intrusive(id->GetVal()); id = global_scope()->Find("preserve_other_addr"); if ( id ) - anon_preserve_other_addr = zeek::cast_intrusive(id->GetVal()); + anon_preserve_other_addr = cast_intrusive(id->GetVal()); } -ipaddr32_t zeek::detail::anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl) +ipaddr32_t anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl) { TableVal* preserve_addr = nullptr; - auto addr = zeek::make_intrusive(ip); + auto addr = make_intrusive(ip); int method = -1; @@ -421,14 +422,14 @@ ipaddr32_t zeek::detail::anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_ new_ip = ip; else if ( ! ip_anonymizer[method] ) - zeek::reporter->InternalError("IP anonymizer not initialized"); + reporter->InternalError("IP anonymizer not initialized"); else new_ip = ip_anonymizer[method]->Anonymize(ip); } else - zeek::reporter->InternalError("invalid IP anonymization method"); + reporter->InternalError("invalid IP anonymization method"); #ifdef LOG_ANONYMIZATION_MAPPING log_anonymization_mapping(ip, new_ip); @@ -438,16 +439,15 @@ ipaddr32_t zeek::detail::anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_ #ifdef LOG_ANONYMIZATION_MAPPING -#include "NetVar.h" -#include "Event.h" - -void zeek::detail::log_anonymization_mapping(ipaddr32_t input, ipaddr32_t output) +void log_anonymization_mapping(ipaddr32_t input, ipaddr32_t output) { if ( anonymization_mapping ) - zeek::event_mgr.Enqueue(anonymization_mapping, - zeek::make_intrusive(input), - zeek::make_intrusive(output) + event_mgr.Enqueue(anonymization_mapping, + make_intrusive(input), + make_intrusive(output) ); } #endif + +} // namespace zeek::detail diff --git a/src/Attr.cc b/src/Attr.cc index 8f6b54a13c..10283a3f2b 100644 --- a/src/Attr.cc +++ b/src/Attr.cc @@ -50,7 +50,7 @@ std::string Attr::DeprecationMessage() const if ( ! expr ) return ""; - auto ce = static_cast(expr.get()); + auto ce = static_cast(expr.get()); return ce->Value()->AsStringVal()->CheckString(); } @@ -164,7 +164,7 @@ Attributes::Attributes(AttrPList* a, TypePtr t, bool arg_in_record, bool is_glob // the necessary checking gets done. for ( const auto& attr : *a ) - AddAttr({zeek::NewRef{}, attr}); + AddAttr({NewRef{}, attr}); delete a; } @@ -209,7 +209,7 @@ void Attributes::AddAttr(AttrPtr attr) if ( (attr->Tag() == ATTR_ADD_FUNC || attr->Tag() == ATTR_DEL_FUNC) && ! Find(ATTR_REDEF) ) { - auto a = zeek::make_intrusive(ATTR_REDEF); + auto a = make_intrusive(ATTR_REDEF); attrs_list.push_back(a.get()); attrs.emplace_back(std::move(a)); } @@ -218,7 +218,7 @@ void Attributes::AddAttr(AttrPtr attr) if ( ! global_var && attr->Tag() == ATTR_DEFAULT && ! Find(ATTR_OPTIONAL) ) { - auto a = zeek::make_intrusive(ATTR_OPTIONAL); + auto a = make_intrusive(ATTR_OPTIONAL); attrs_list.push_back(a.get()); attrs.emplace_back(std::move(a)); } diff --git a/src/Attr.h b/src/Attr.h index 5c110bfe7f..7c4866ebbb 100644 --- a/src/Attr.h +++ b/src/Attr.h @@ -22,7 +22,7 @@ using TypePtr = IntrusivePtr; namespace detail { -using ExprPtr = zeek::IntrusivePtr; +using ExprPtr = IntrusivePtr; enum AttrTag { ATTR_OPTIONAL, @@ -50,9 +50,9 @@ enum AttrTag { }; class Attr; -using AttrPtr = zeek::IntrusivePtr; +using AttrPtr = IntrusivePtr; class Attributes; -using AttributesPtr = zeek::IntrusivePtr; +using AttributesPtr = IntrusivePtr; class Attr final : public Obj { public: @@ -66,7 +66,7 @@ public: AttrTag Tag() const { return tag; } [[deprecated("Remove in v4.1. Use GetExpr().")]] - zeek::detail::Expr* AttrExpr() const { return expr.get(); } + Expr* AttrExpr() const { return expr.get(); } const ExprPtr& GetExpr() const { return expr; } @@ -107,9 +107,9 @@ protected: class Attributes final : public Obj { public: [[deprecated("Remove in v4.1. Construct using IntrusivePtrs instead.")]] - Attributes(AttrPList* a, zeek::TypePtr t, bool in_record, bool is_global); + Attributes(AttrPList* a, TypePtr t, bool in_record, bool is_global); - Attributes(std::vector a, zeek::TypePtr t, + Attributes(std::vector a, TypePtr t, bool in_record, bool is_global); Attributes(TypePtr t, bool in_record, bool is_global); diff --git a/src/Base64.cc b/src/Base64.cc index a50f6121d3..8c0e5f2c59 100644 --- a/src/Base64.cc +++ b/src/Base64.cc @@ -17,10 +17,10 @@ void Base64Converter::Encode(int len, const unsigned char* data, int* pblen, cha char *buf; if ( ! pbuf ) - zeek::reporter->InternalError("nil pointer to encoding result buffer"); + reporter->InternalError("nil pointer to encoding result buffer"); if ( *pbuf && (*pblen % 4 != 0) ) - zeek::reporter->InternalError("Base64 encode buffer not a multiple of 4"); + reporter->InternalError("Base64 encode buffer not a multiple of 4"); if ( *pbuf ) { @@ -88,7 +88,7 @@ int* Base64Converter::InitBase64Table(const std::string& alphabet) return base64_table; } -Base64Converter::Base64Converter(zeek::Connection* arg_conn, const std::string& arg_alphabet) +Base64Converter::Base64Converter(Connection* arg_conn, const std::string& arg_alphabet) { if ( arg_alphabet.size() > 0 ) { @@ -123,7 +123,7 @@ int Base64Converter::Decode(int len, const char* data, int* pblen, char** pbuf) base64_table = InitBase64Table(alphabet); if ( ! pbuf ) - zeek::reporter->InternalError("nil pointer to decoding result buffer"); + reporter->InternalError("nil pointer to decoding result buffer"); if ( *pbuf ) { @@ -193,7 +193,7 @@ int Base64Converter::Decode(int len, const char* data, int* pblen, char** pbuf) else { if ( ++errored == 1 ) - IllegalEncoding(zeek::util::fmt("character %d ignored by Base64 decoding", (int) (data[dlen]))); + IllegalEncoding(util::fmt("character %d ignored by Base64 decoding", (int) (data[dlen]))); } ++dlen; @@ -210,8 +210,8 @@ int Base64Converter::Done(int* pblen, char** pbuf) if ( base64_group_next != 0 ) { if ( base64_group_next < 4 ) - IllegalEncoding(zeek::util::fmt("incomplete base64 group, padding with %d bits of 0", - (4-base64_group_next) * 6)); + IllegalEncoding(util::fmt("incomplete base64 group, padding with %d bits of 0", + (4-base64_group_next) * 6)); Decode(4 - base64_group_next, padding, pblen, pbuf); return -1; } @@ -228,15 +228,15 @@ void Base64Converter::IllegalEncoding(const char* msg) if ( conn ) conn->Weird("base64_illegal_encoding", msg); else - zeek::reporter->Error("%s", msg); + reporter->Error("%s", msg); } -zeek::String* decode_base64(const zeek::String* s, const zeek::String* a, zeek::Connection* conn) +String* decode_base64(const String* s, const String* a, Connection* conn) { if ( a && a->Len() != 0 && a->Len() != 64 ) { - zeek::reporter->Error("base64 decoding alphabet is not 64 characters: %s", - a->CheckString()); + reporter->Error("base64 decoding alphabet is not 64 characters: %s", + a->CheckString()); return nullptr; } @@ -258,18 +258,18 @@ zeek::String* decode_base64(const zeek::String* s, const zeek::String* a, zeek:: rlen += rlen2; rbuf[rlen] = '\0'; - return new zeek::String(true, (u_char*) rbuf, rlen); + return new String(true, (u_char*) rbuf, rlen); err: delete [] rbuf; return nullptr; } -zeek::String* encode_base64(const zeek::String* s, const zeek::String* a, zeek::Connection* conn) +String* encode_base64(const String* s, const String* a, Connection* conn) { if ( a && a->Len() != 0 && a->Len() != 64 ) { - zeek::reporter->Error("base64 alphabet is not 64 characters: %s", + reporter->Error("base64 alphabet is not 64 characters: %s", a->CheckString()); return nullptr; } @@ -279,7 +279,7 @@ zeek::String* encode_base64(const zeek::String* s, const zeek::String* a, zeek:: Base64Converter enc(conn, a ? a->CheckString() : ""); enc.Encode(s->Len(), (const unsigned char*) s->Bytes(), &outlen, &outbuf); - return new zeek::String(true, (u_char*)outbuf, outlen); + return new String(true, (u_char*)outbuf, outlen); } } // namespace zeek::detail diff --git a/src/Base64.h b/src/Base64.h index ae514dad71..28a7adb7d1 100644 --- a/src/Base64.h +++ b/src/Base64.h @@ -62,8 +62,8 @@ protected: }; -zeek::String* decode_base64(const zeek::String* s, const zeek::String* a = nullptr, zeek::Connection* conn = nullptr); -zeek::String* encode_base64(const zeek::String* s, const zeek::String* a = nullptr, zeek::Connection* conn = nullptr); +String* decode_base64(const String* s, const String* a = nullptr, Connection* conn = nullptr); +String* encode_base64(const String* s, const String* a = nullptr, Connection* conn = nullptr); } // namespace zeek::detail diff --git a/src/BifReturnVal.cc b/src/BifReturnVal.cc index e75871f377..e8ea9facf1 100644 --- a/src/BifReturnVal.cc +++ b/src/BifReturnVal.cc @@ -8,8 +8,8 @@ namespace zeek::detail { BifReturnVal::BifReturnVal(std::nullptr_t) noexcept {} -BifReturnVal::BifReturnVal(zeek::Val* v) noexcept - : rval(zeek::AdoptRef{}, v) +BifReturnVal::BifReturnVal(Val* v) noexcept + : rval(AdoptRef{}, v) {} } // namespace zeek::detail diff --git a/src/BifReturnVal.h b/src/BifReturnVal.h index 3ac31c6c74..5a49714e8e 100644 --- a/src/BifReturnVal.h +++ b/src/BifReturnVal.h @@ -7,7 +7,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Val, zeek); namespace zeek { -using ValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; } namespace zeek::detail { @@ -21,16 +21,16 @@ class BifReturnVal { public: template - BifReturnVal(zeek::IntrusivePtr v) noexcept - : rval(zeek::AdoptRef{}, v.release()) + BifReturnVal(IntrusivePtr v) noexcept + : rval(AdoptRef{}, v.release()) { } BifReturnVal(std::nullptr_t) noexcept; [[deprecated("Remove in v4.1. Return an IntrusivePtr instead.")]] - BifReturnVal(zeek::Val* v) noexcept; + BifReturnVal(Val* v) noexcept; - zeek::ValPtr rval; + ValPtr rval; }; } // namespace zeek::detail diff --git a/src/CCL.cc b/src/CCL.cc index 6c015c6a55..a55025c8cc 100644 --- a/src/CCL.cc +++ b/src/CCL.cc @@ -48,7 +48,7 @@ void CCL::Sort() unsigned int CCL::MemoryAllocation() const { - return padded_sizeof(*this) + padded_sizeof(*syms) + zeek::util::pad_size(syms->size() * sizeof(int_list::value_type)); + return padded_sizeof(*this) + padded_sizeof(*syms) + util::pad_size(syms->size() * sizeof(int_list::value_type)); } } // namespace zeek::detail diff --git a/src/CompHash.cc b/src/CompHash.cc index 79689ef56e..9fcebb53f8 100644 --- a/src/CompHash.cc +++ b/src/CompHash.cc @@ -17,17 +17,17 @@ namespace zeek::detail { -CompositeHash::CompositeHash(zeek::TypeListPtr composite_type) +CompositeHash::CompositeHash(TypeListPtr composite_type) : type(std::move(composite_type)) { - singleton_tag = zeek::TYPE_INTERNAL_ERROR; + singleton_tag = TYPE_INTERNAL_ERROR; // If the only element is a record, don't treat it as a // singleton, since it needs to be evaluated specially. if ( type->GetTypes().size() == 1 ) { - if ( type->GetTypes()[0]->Tag() == zeek::TYPE_RECORD ) + if ( type->GetTypes()[0]->Tag() == TYPE_RECORD ) { is_complex_type = true; is_singleton = false; @@ -74,10 +74,10 @@ CompositeHash::~CompositeHash() // Computes the piece of the hash for Val*, returning the new kp. char* CompositeHash::SingleValHash(bool type_check, char* kp0, - zeek::Type* bt, zeek::Val* v, bool optional) const + Type* bt, Val* v, bool optional) const { char* kp1 = nullptr; - zeek::InternalTypeTag t = bt->InternalType(); + InternalTypeTag t = bt->InternalType(); if ( optional ) { @@ -92,13 +92,13 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, if ( type_check ) { - zeek::InternalTypeTag vt = v->GetType()->InternalType(); + InternalTypeTag vt = v->GetType()->InternalType(); if ( vt != t ) return nullptr; } switch ( t ) { - case zeek::TYPE_INTERNAL_INT: + case TYPE_INTERNAL_INT: { bro_int_t* kp = AlignAndPadType(kp0); *kp = v->ForceAsInt(); @@ -106,7 +106,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_UNSIGNED: + case TYPE_INTERNAL_UNSIGNED: { bro_uint_t* kp = AlignAndPadType(kp0); *kp = v->ForceAsUInt(); @@ -114,7 +114,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_ADDR: + case TYPE_INTERNAL_ADDR: { uint32_t* kp = AlignAndPadType(kp0); v->AsAddr().CopyIPv6(kp); @@ -122,7 +122,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_SUBNET: + case TYPE_INTERNAL_SUBNET: { uint32_t* kp = AlignAndPadType(kp0); v->AsSubNet().Prefix().CopyIPv6(kp); @@ -131,7 +131,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_DOUBLE: + case TYPE_INTERNAL_DOUBLE: { double* kp = AlignAndPadType(kp0); *kp = v->InternalDouble(); @@ -139,11 +139,11 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_VOID: - case zeek::TYPE_INTERNAL_OTHER: + case TYPE_INTERNAL_VOID: + case TYPE_INTERNAL_OTHER: { switch ( v->GetType()->Tag() ) { - case zeek::TYPE_FUNC: + case TYPE_FUNC: { uint32_t* kp = AlignAndPadType(kp0); *kp = v->AsFunc()->GetUniqueFuncID(); @@ -151,7 +151,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, break; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { const char* texts[2] = { v->AsPattern()->PatternText(), @@ -175,19 +175,19 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, break; } - case zeek::TYPE_RECORD: + case TYPE_RECORD: { char* kp = kp0; - zeek::RecordVal* rv = v->AsRecordVal(); - zeek::RecordType* rt = bt->AsRecordType(); + RecordVal* rv = v->AsRecordVal(); + RecordType* rt = bt->AsRecordType(); int num_fields = rt->NumFields(); for ( int i = 0; i < num_fields; ++i ) { auto rv_i = rv->GetField(i).get(); - zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get(); - bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL)); + Attributes* a = rt->FieldDecl(i)->attrs.get(); + bool optional = (a && a->Find(ATTR_OPTIONAL)); if ( ! (rv_i || optional) ) return nullptr; @@ -202,19 +202,19 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { int* kp = AlignAndPadType(kp0); - zeek::TableVal* tv = v->AsTableVal(); + TableVal* tv = v->AsTableVal(); *kp = tv->Size(); kp1 = reinterpret_cast(kp+1); auto tbl = tv->AsTable(); auto it = tbl->InitForIteration(); - auto lv = zeek::make_intrusive(zeek::TYPE_ANY); + auto lv = make_intrusive(TYPE_ANY); struct HashKeyComparer { - bool operator()(const zeek::detail::HashKey* a, const zeek::detail::HashKey* b) const + bool operator()(const HashKey* a, const HashKey* b) const { if ( a->Hash() != b->Hash() ) return a->Hash() < b->Hash(); @@ -226,8 +226,8 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } }; - std::map hashkeys; - zeek::detail::HashKey* k; + std::map hashkeys; + HashKey* k; auto idx = 0; while ( tbl->NextEntry(k, it) ) @@ -261,11 +261,11 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { unsigned int* kp = AlignAndPadType(kp0); - zeek::VectorVal* vv = v->AsVectorVal(); - zeek::VectorType* vt = v->GetType()->AsVectorType(); + VectorVal* vv = v->AsVectorVal(); + VectorType* vt = v->GetType()->AsVectorType(); *kp = vv->Size(); kp1 = reinterpret_cast(kp+1); for ( unsigned int i = 0; i < vv->Size(); ++i ) @@ -289,15 +289,15 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_LIST: + case TYPE_LIST: { int* kp = AlignAndPadType(kp0); - zeek::ListVal* lv = v->AsListVal(); + ListVal* lv = v->AsListVal(); *kp = lv->Length(); kp1 = reinterpret_cast(kp+1); for ( int i = 0; i < lv->Length(); ++i ) { - zeek::Val* v = lv->Idx(i).get(); + Val* v = lv->Idx(i).get(); if ( ! (kp1 = SingleValHash(type_check, kp1, v->GetType().get(), v, false)) ) return nullptr; @@ -307,19 +307,19 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, default: { - zeek::reporter->InternalError("bad index type in CompositeHash::SingleValHash"); + reporter->InternalError("bad index type in CompositeHash::SingleValHash"); return nullptr; } } - break; // case zeek::TYPE_INTERNAL_VOID/OTHER + break; // case TYPE_INTERNAL_VOID/OTHER } - case zeek::TYPE_INTERNAL_STRING: + case TYPE_INTERNAL_STRING: { // Align to int for the length field. int* kp = AlignAndPadType(kp0); - const zeek::String* sval = v->AsString(); + const String* sval = v->AsString(); *kp = sval->Len(); // so we can recover the value @@ -330,7 +330,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } break; - case zeek::TYPE_INTERNAL_ERROR: + case TYPE_INTERNAL_ERROR: return nullptr; } @@ -338,22 +338,22 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, } -std::unique_ptr CompositeHash::MakeHashKey(const zeek::Val& argv, bool type_check) const +std::unique_ptr CompositeHash::MakeHashKey(const Val& argv, bool type_check) const { auto v = &argv; if ( is_singleton ) return ComputeSingletonHash(v, type_check); - if ( is_complex_type && v->GetType()->Tag() != zeek::TYPE_LIST ) + if ( is_complex_type && v->GetType()->Tag() != TYPE_LIST ) { - zeek::ListVal lv(zeek::TYPE_ANY); + ListVal lv(TYPE_ANY); // Cast away const to use ListVal - but since we // re-introduce const on the recursive call, it should // be okay; the only thing is that the ListVal unref's it. - zeek::Val* ncv = (zeek::Val*) v; - lv.Append({zeek::NewRef{}, ncv}); + Val* ncv = (Val*) v; + lv.Append({NewRef{}, ncv}); return MakeHashKey(lv, type_check); } @@ -371,7 +371,7 @@ std::unique_ptr CompositeHash::MakeHashKey(const zeek::Va const auto& tl = type->GetTypes(); - if ( type_check && v->GetType()->Tag() != zeek::TYPE_LIST ) + if ( type_check && v->GetType()->Tag() != TYPE_LIST ) return nullptr; auto lv = v->AsListVal(); @@ -387,12 +387,12 @@ std::unique_ptr CompositeHash::MakeHashKey(const zeek::Va return nullptr; } - return std::make_unique((k == key), (void*) k, kp - k); + return std::make_unique((k == key), (void*) k, kp - k); } -std::unique_ptr CompositeHash::ComputeSingletonHash(const zeek::Val* v, bool type_check) const +std::unique_ptr CompositeHash::ComputeSingletonHash(const Val* v, bool type_check) const { - if ( v->GetType()->Tag() == zeek::TYPE_LIST ) + if ( v->GetType()->Tag() == TYPE_LIST ) { auto lv = v->AsListVal(); @@ -406,25 +406,25 @@ std::unique_ptr CompositeHash::ComputeSingletonHash(const return nullptr; switch ( singleton_tag ) { - case zeek::TYPE_INTERNAL_INT: - case zeek::TYPE_INTERNAL_UNSIGNED: - return std::make_unique(v->ForceAsInt()); + case TYPE_INTERNAL_INT: + case TYPE_INTERNAL_UNSIGNED: + return std::make_unique(v->ForceAsInt()); - case zeek::TYPE_INTERNAL_ADDR: + case TYPE_INTERNAL_ADDR: return v->AsAddr().MakeHashKey(); - case zeek::TYPE_INTERNAL_SUBNET: + case TYPE_INTERNAL_SUBNET: return v->AsSubNet().MakeHashKey(); - case zeek::TYPE_INTERNAL_DOUBLE: - return std::make_unique(v->InternalDouble()); + case TYPE_INTERNAL_DOUBLE: + return std::make_unique(v->InternalDouble()); - case zeek::TYPE_INTERNAL_VOID: - case zeek::TYPE_INTERNAL_OTHER: - if ( v->GetType()->Tag() == zeek::TYPE_FUNC ) - return std::make_unique(v->AsFunc()->GetUniqueFuncID()); + case TYPE_INTERNAL_VOID: + case TYPE_INTERNAL_OTHER: + if ( v->GetType()->Tag() == TYPE_FUNC ) + return std::make_unique(v->AsFunc()->GetUniqueFuncID()); - if ( v->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( v->GetType()->Tag() == TYPE_PATTERN ) { const char* texts[2] = { v->AsPattern()->PatternText(), @@ -434,71 +434,71 @@ std::unique_ptr CompositeHash::ComputeSingletonHash(const char* key = new char[n]; std::memcpy(key, texts[0], strlen(texts[0]) + 1); std::memcpy(key + strlen(texts[0]) + 1, texts[1], strlen(texts[1]) + 1); - return std::make_unique(false, key, n); + return std::make_unique(false, key, n); } - zeek::reporter->InternalError("bad index type in CompositeHash::ComputeSingletonHash"); + reporter->InternalError("bad index type in CompositeHash::ComputeSingletonHash"); return nullptr; - case zeek::TYPE_INTERNAL_STRING: - return std::make_unique(v->AsString()); + case TYPE_INTERNAL_STRING: + return std::make_unique(v->AsString()); - case zeek::TYPE_INTERNAL_ERROR: + case TYPE_INTERNAL_ERROR: return nullptr; default: - zeek::reporter->InternalError("bad internal type in CompositeHash::ComputeSingletonHash"); + reporter->InternalError("bad internal type in CompositeHash::ComputeSingletonHash"); return nullptr; } } -int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, +int CompositeHash::SingleTypeKeySize(Type* bt, const Val* v, bool type_check, int sz, bool optional, bool calc_static_size) const { - zeek::InternalTypeTag t = bt->InternalType(); + InternalTypeTag t = bt->InternalType(); if ( optional ) sz = SizeAlign(sz, sizeof(char)); if ( type_check && v ) { - zeek::InternalTypeTag vt = v->GetType()->InternalType(); + InternalTypeTag vt = v->GetType()->InternalType(); if ( vt != t ) return 0; } switch ( t ) { - case zeek::TYPE_INTERNAL_INT: - case zeek::TYPE_INTERNAL_UNSIGNED: + case TYPE_INTERNAL_INT: + case TYPE_INTERNAL_UNSIGNED: sz = SizeAlign(sz, sizeof(bro_int_t)); break; - case zeek::TYPE_INTERNAL_ADDR: + case TYPE_INTERNAL_ADDR: sz = SizeAlign(sz, sizeof(uint32_t)); sz += sizeof(uint32_t) * 3; // to make a total of 4 words break; - case zeek::TYPE_INTERNAL_SUBNET: + case TYPE_INTERNAL_SUBNET: sz = SizeAlign(sz, sizeof(uint32_t)); sz += sizeof(uint32_t) * 4; // to make a total of 5 words break; - case zeek::TYPE_INTERNAL_DOUBLE: + case TYPE_INTERNAL_DOUBLE: sz = SizeAlign(sz, sizeof(double)); break; - case zeek::TYPE_INTERNAL_VOID: - case zeek::TYPE_INTERNAL_OTHER: + case TYPE_INTERNAL_VOID: + case TYPE_INTERNAL_OTHER: { switch ( bt->Tag() ) { - case zeek::TYPE_FUNC: + case TYPE_FUNC: { sz = SizeAlign(sz, sizeof(uint32_t)); break; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { if ( ! v ) return (optional && ! calc_static_size) ? sz : 0; @@ -509,16 +509,16 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, break; } - case zeek::TYPE_RECORD: + case TYPE_RECORD: { - const zeek::RecordVal* rv = v ? v->AsRecordVal() : nullptr; - zeek::RecordType* rt = bt->AsRecordType(); + const RecordVal* rv = v ? v->AsRecordVal() : nullptr; + RecordType* rt = bt->AsRecordType(); int num_fields = rt->NumFields(); for ( int i = 0; i < num_fields; ++i ) { - zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get(); - bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL)); + Attributes* a = rt->FieldDecl(i)->attrs.get(); + bool optional = (a && a->Find(ATTR_OPTIONAL)); sz = SingleTypeKeySize(rt->GetFieldType(i).get(), rv ? rv->GetField(i).get() : nullptr, @@ -531,13 +531,13 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( ! v ) return (optional && ! calc_static_size) ? sz : 0; sz = SizeAlign(sz, sizeof(int)); - zeek::TableVal* tv = const_cast(v->AsTableVal()); + TableVal* tv = const_cast(v->AsTableVal()); auto lv = tv->ToListVal(); for ( int i = 0; i < tv->Size(); ++i ) { @@ -560,13 +560,13 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, break; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( ! v ) return (optional && ! calc_static_size) ? sz : 0; sz = SizeAlign(sz, sizeof(unsigned int)); - zeek::VectorVal* vv = const_cast(v->AsVectorVal()); + VectorVal* vv = const_cast(v->AsVectorVal()); for ( unsigned int i = 0; i < vv->Size(); ++i ) { const auto& val = vv->At(i); @@ -582,13 +582,13 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, break; } - case zeek::TYPE_LIST: + case TYPE_LIST: { if ( ! v ) return (optional && ! calc_static_size) ? sz : 0; sz = SizeAlign(sz, sizeof(int)); - zeek::ListVal* lv = const_cast(v->AsListVal()); + ListVal* lv = const_cast(v->AsListVal()); for ( int i = 0; i < lv->Length(); ++i ) { sz = SingleTypeKeySize(lv->Idx(i)->GetType().get(), lv->Idx(i).get(), @@ -601,15 +601,15 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, default: { - zeek::reporter->InternalError("bad index type in CompositeHash::CompositeHash"); + reporter->InternalError("bad index type in CompositeHash::CompositeHash"); return 0; } } - break; // case zeek::TYPE_INTERNAL_VOID/OTHER + break; // case TYPE_INTERNAL_VOID/OTHER } - case zeek::TYPE_INTERNAL_STRING: + case TYPE_INTERNAL_STRING: if ( ! v ) return (optional && ! calc_static_size) ? sz : 0; @@ -618,20 +618,20 @@ int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const zeek::Val* v, sz += v->AsString()->Len(); break; - case zeek::TYPE_INTERNAL_ERROR: + case TYPE_INTERNAL_ERROR: return 0; } return sz; } -int CompositeHash::ComputeKeySize(const zeek::Val* v, bool type_check, bool calc_static_size) const +int CompositeHash::ComputeKeySize(const Val* v, bool type_check, bool calc_static_size) const { const auto& tl = type->GetTypes(); if ( v ) { - if ( type_check && v->GetType()->Tag() != zeek::TYPE_LIST ) + if ( type_check && v->GetType()->Tag() != TYPE_LIST ) return 0; auto lv = v->AsListVal(); @@ -711,38 +711,38 @@ int CompositeHash::SizeAlign(int offset, unsigned int size) const return offset; } -zeek::ListValPtr CompositeHash::RecoverVals(const zeek::detail::HashKey& k) const +ListValPtr CompositeHash::RecoverVals(const HashKey& k) const { - auto l = zeek::make_intrusive(zeek::TYPE_ANY); + auto l = make_intrusive(TYPE_ANY); const auto& tl = type->GetTypes(); const char* kp = (const char*) k.Key(); const char* const k_end = kp + k.Size(); for ( const auto& type : tl ) { - zeek::ValPtr v; + ValPtr v; kp = RecoverOneVal(k, kp, k_end, type.get(), &v, false); ASSERT(v); l->Append(std::move(v)); } if ( kp != k_end ) - zeek::reporter->InternalError("under-ran key in CompositeHash::DescribeKey %zd", k_end - kp); + reporter->InternalError("under-ran key in CompositeHash::DescribeKey %zd", k_end - kp); return l; } const char* CompositeHash::RecoverOneVal( - const zeek::detail::HashKey& k, const char* kp0, - const char* const k_end, zeek::Type* t, - zeek::ValPtr* pval, bool optional) const + const HashKey& k, const char* kp0, + const char* const k_end, Type* t, + ValPtr* pval, bool optional) const { // k->Size() == 0 for a single empty string. if ( kp0 >= k_end && k.Size() > 0 ) - zeek::reporter->InternalError("over-ran key in CompositeHash::RecoverVals"); + reporter->InternalError("over-ran key in CompositeHash::RecoverVals"); - zeek::TypeTag tag = t->Tag(); - zeek::InternalTypeTag it = t->InternalType(); + TypeTag tag = t->Tag(); + InternalTypeTag it = t->InternalType(); const char* kp1 = nullptr; if ( optional ) @@ -758,128 +758,128 @@ const char* CompositeHash::RecoverOneVal( } switch ( it ) { - case zeek::TYPE_INTERNAL_INT: + case TYPE_INTERNAL_INT: { const bro_int_t* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+1); - if ( tag == zeek::TYPE_ENUM ) + if ( tag == TYPE_ENUM ) *pval = t->AsEnumType()->GetEnumVal(*kp); - else if ( tag == zeek::TYPE_BOOL ) - *pval = zeek::val_mgr->Bool(*kp); - else if ( tag == zeek::TYPE_INT ) - *pval = zeek::val_mgr->Int(*kp); + else if ( tag == TYPE_BOOL ) + *pval = val_mgr->Bool(*kp); + else if ( tag == TYPE_INT ) + *pval = val_mgr->Int(*kp); else { - zeek::reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()"); + reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()"); *pval = nullptr; } } break; - case zeek::TYPE_INTERNAL_UNSIGNED: + case TYPE_INTERNAL_UNSIGNED: { const bro_uint_t* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+1); switch ( tag ) { - case zeek::TYPE_COUNT: - *pval = zeek::val_mgr->Count(*kp); + case TYPE_COUNT: + *pval = val_mgr->Count(*kp); break; - case zeek::TYPE_PORT: - *pval = zeek::val_mgr->Port(*kp); + case TYPE_PORT: + *pval = val_mgr->Port(*kp); break; default: - zeek::reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()"); + reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()"); *pval = nullptr; break; } } break; - case zeek::TYPE_INTERNAL_DOUBLE: + case TYPE_INTERNAL_DOUBLE: { const double* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+1); - if ( tag == zeek::TYPE_INTERVAL ) - *pval = zeek::make_intrusive(*kp, 1.0); - else if ( tag == zeek::TYPE_TIME ) - *pval = zeek::make_intrusive(*kp); + if ( tag == TYPE_INTERVAL ) + *pval = make_intrusive(*kp, 1.0); + else if ( tag == TYPE_TIME ) + *pval = make_intrusive(*kp); else - *pval = zeek::make_intrusive(*kp); + *pval = make_intrusive(*kp); } break; - case zeek::TYPE_INTERNAL_ADDR: + case TYPE_INTERNAL_ADDR: { const uint32_t* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+4); - zeek::IPAddr addr(IPv6, kp, zeek::IPAddr::Network); + IPAddr addr(IPv6, kp, IPAddr::Network); switch ( tag ) { - case zeek::TYPE_ADDR: - *pval = zeek::make_intrusive(addr); + case TYPE_ADDR: + *pval = make_intrusive(addr); break; default: - zeek::reporter->InternalError("bad internal address in CompositeHash::RecoverOneVal()"); + reporter->InternalError("bad internal address in CompositeHash::RecoverOneVal()"); *pval = nullptr; break; } } break; - case zeek::TYPE_INTERNAL_SUBNET: + case TYPE_INTERNAL_SUBNET: { const uint32_t* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+5); - *pval = zeek::make_intrusive(kp, kp[4]); + *pval = make_intrusive(kp, kp[4]); } break; - case zeek::TYPE_INTERNAL_VOID: - case zeek::TYPE_INTERNAL_OTHER: + case TYPE_INTERNAL_VOID: + case TYPE_INTERNAL_OTHER: { switch ( t->Tag() ) { - case zeek::TYPE_FUNC: + case TYPE_FUNC: { const uint32_t* const kp = AlignType(kp0); kp1 = reinterpret_cast(kp+1); - const auto& f = zeek::Func::GetFuncPtrByID(*kp); + const auto& f = Func::GetFuncPtrByID(*kp); if ( ! f ) - zeek::reporter->InternalError("failed to look up unique function id %" PRIu32 " in CompositeHash::RecoverOneVal()", *kp); + reporter->InternalError("failed to look up unique function id %" PRIu32 " in CompositeHash::RecoverOneVal()", *kp); - *pval = zeek::make_intrusive(f); + *pval = make_intrusive(f); const auto& pvt = (*pval)->GetType(); if ( ! pvt ) - zeek::reporter->InternalError("bad aggregate Val in CompositeHash::RecoverOneVal()"); + reporter->InternalError("bad aggregate Val in CompositeHash::RecoverOneVal()"); - else if ( t->Tag() != zeek::TYPE_FUNC && ! same_type(pvt, t) ) + else if ( t->Tag() != TYPE_FUNC && ! same_type(pvt, t) ) // ### Maybe fix later, but may be fundamentally // un-checkable --US - zeek::reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()"); + reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()"); // ### A crude approximation for now. - else if ( t->Tag() == zeek::TYPE_FUNC && pvt->Tag() != zeek::TYPE_FUNC ) - zeek::reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()"); + else if ( t->Tag() == TYPE_FUNC && pvt->Tag() != TYPE_FUNC ) + reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()"); } break; - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { - zeek::RE_Matcher* re = nullptr; + RE_Matcher* re = nullptr; if ( is_singleton ) { kp1 = kp0; int divider = strlen(kp0) + 1; - re = new zeek::RE_Matcher(kp1, kp1 + divider); + re = new RE_Matcher(kp1, kp1 + divider); kp1 += k.Size(); } else @@ -887,32 +887,32 @@ const char* CompositeHash::RecoverOneVal( const uint64_t* const len = AlignType(kp0); kp1 = reinterpret_cast(len+2); - re = new zeek::RE_Matcher(kp1, kp1 + len[0]); + re = new RE_Matcher(kp1, kp1 + len[0]); kp1 += len[0] + len[1]; } if ( ! re->Compile() ) - zeek::reporter->InternalError("failed compiling table/set key pattern: %s", + reporter->InternalError("failed compiling table/set key pattern: %s", re->PatternText()); - *pval = zeek::make_intrusive(re); + *pval = make_intrusive(re); } break; - case zeek::TYPE_RECORD: + case TYPE_RECORD: { const char* kp = kp0; - zeek::RecordType* rt = t->AsRecordType(); + RecordType* rt = t->AsRecordType(); int num_fields = rt->NumFields(); - std::vector values; + std::vector values; int i; for ( i = 0; i < num_fields; ++i ) { - zeek::ValPtr v; + ValPtr v; - zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get(); - bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL)); + Attributes* a = rt->FieldDecl(i)->attrs.get(); + bool optional = (a && a->Find(ATTR_OPTIONAL)); kp = RecoverOneVal(k, kp, k_end, rt->GetFieldType(i).get(), &v, optional); @@ -922,7 +922,7 @@ const char* CompositeHash::RecoverOneVal( // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch) if ( ! (v || optional) ) { - zeek::reporter->InternalError("didn't recover expected number of fields from HashKey"); + reporter->InternalError("didn't recover expected number of fields from HashKey"); pval = nullptr; break; } @@ -932,7 +932,7 @@ const char* CompositeHash::RecoverOneVal( ASSERT(int(values.size()) == num_fields); - auto rv = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, rt}); + auto rv = make_intrusive(IntrusivePtr{NewRef{}, rt}); for ( int i = 0; i < num_fields; ++i ) rv->Assign(i, std::move(values[i])); @@ -942,25 +942,25 @@ const char* CompositeHash::RecoverOneVal( } break; - case zeek::TYPE_TABLE: + case TYPE_TABLE: { int n; const int* const kp = AlignType(kp0); n = *kp; kp1 = reinterpret_cast(kp+1); - zeek::TableType* tt = t->AsTableType(); - auto tv = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, tt}); + TableType* tt = t->AsTableType(); + auto tv = make_intrusive(IntrusivePtr{NewRef{}, tt}); for ( int i = 0; i < n; ++i ) { - zeek::ValPtr key; + ValPtr key; kp1 = RecoverOneVal(k, kp1, k_end, tt->GetIndices().get(), &key, false); if ( t->IsSet() ) tv->Assign(std::move(key), nullptr); else { - zeek::ValPtr value; + ValPtr value; kp1 = RecoverOneVal(k, kp1, k_end, tt->Yield().get(), &value, false); tv->Assign(std::move(key), std::move(value)); @@ -971,14 +971,14 @@ const char* CompositeHash::RecoverOneVal( } break; - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { unsigned int n; const unsigned int* kp = AlignType(kp0); n = *kp; kp1 = reinterpret_cast(kp+1); - zeek::VectorType* vt = t->AsVectorType(); - auto vv = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, vt}); + VectorType* vt = t->AsVectorType(); + auto vv = make_intrusive(IntrusivePtr{NewRef{}, vt}); for ( unsigned int i = 0; i < n; ++i ) { @@ -988,7 +988,7 @@ const char* CompositeHash::RecoverOneVal( kp = AlignType(kp1); unsigned int have_val = *kp; kp1 = reinterpret_cast(kp+1); - zeek::ValPtr value; + ValPtr value; if ( have_val ) kp1 = RecoverOneVal(k, kp1, k_end, vt->Yield().get(), &value, @@ -1001,19 +1001,19 @@ const char* CompositeHash::RecoverOneVal( } break; - case zeek::TYPE_LIST: + case TYPE_LIST: { int n; const int* const kp = AlignType(kp0); n = *kp; kp1 = reinterpret_cast(kp+1); - zeek::TypeList* tl = t->AsTypeList(); - auto lv = zeek::make_intrusive(zeek::TYPE_ANY); + TypeList* tl = t->AsTypeList(); + auto lv = make_intrusive(TYPE_ANY); for ( int i = 0; i < n; ++i ) { - zeek::ValPtr v; - zeek::Type* it = tl->GetTypes()[i].get(); + ValPtr v; + Type* it = tl->GetTypes()[i].get(); kp1 = RecoverOneVal(k, kp1, k_end, it, &v, false); lv->Append(std::move(v)); } @@ -1024,13 +1024,13 @@ const char* CompositeHash::RecoverOneVal( default: { - zeek::reporter->InternalError("bad index type in CompositeHash::DescribeKey"); + reporter->InternalError("bad index type in CompositeHash::DescribeKey"); } } } break; - case zeek::TYPE_INTERNAL_STRING: + case TYPE_INTERNAL_STRING: { // There is a minor issue here -- the pointer does not have to // be aligned by int in the singleton case. @@ -1048,12 +1048,12 @@ const char* CompositeHash::RecoverOneVal( kp1 = reinterpret_cast(kp+1); } - *pval = zeek::make_intrusive(new zeek::String((const zeek::byte_vec) kp1, n, true)); + *pval = make_intrusive(new String((const byte_vec) kp1, n, true)); kp1 += n; } break; - case zeek::TYPE_INTERNAL_ERROR: + case TYPE_INTERNAL_ERROR: break; } diff --git a/src/CompHash.h b/src/CompHash.h index 50c72482d2..9472987a77 100644 --- a/src/CompHash.h +++ b/src/CompHash.h @@ -18,32 +18,32 @@ namespace zeek::detail { class CompositeHash { public: - explicit CompositeHash(zeek::TypeListPtr composite_type); + explicit CompositeHash(TypeListPtr composite_type); ~CompositeHash(); // Compute the hash corresponding to the given index val, // or nullptr if it fails to typecheck. - std::unique_ptr MakeHashKey(const zeek::Val& v, bool type_check) const; + std::unique_ptr MakeHashKey(const Val& v, bool type_check) const; [[deprecated("Remove in v4.1. Use MakeHashKey().")]] - zeek::detail::HashKey* ComputeHash(const zeek::Val* v, bool type_check) const + HashKey* ComputeHash(const Val* v, bool type_check) const { return MakeHashKey(*v, type_check).release(); } // Given a hash key, recover the values used to create it. - zeek::ListValPtr RecoverVals(const zeek::detail::HashKey& k) const; + ListValPtr RecoverVals(const HashKey& k) const; - [[deprecated("Remove in v4.1. Pass in zeek::detail::HashKey& instead.")]] - zeek::ListValPtr RecoverVals(const zeek::detail::HashKey* k) const + [[deprecated("Remove in v4.1. Pass in HashKey& instead.")]] + ListValPtr RecoverVals(const HashKey* k) const { return RecoverVals(*k); } - unsigned int MemoryAllocation() const { return padded_sizeof(*this) + zeek::util::pad_size(size); } + unsigned int MemoryAllocation() const { return padded_sizeof(*this) + util::pad_size(size); } protected: - std::unique_ptr ComputeSingletonHash(const zeek::Val* v, bool type_check) const; + std::unique_ptr ComputeSingletonHash(const Val* v, bool type_check) const; // Computes the piece of the hash for Val*, returning the new kp. // Used as a helper for ComputeHash in the non-singleton case. - char* SingleValHash(bool type_check, char* kp, zeek::Type* bt, zeek::Val* v, + char* SingleValHash(bool type_check, char* kp, Type* bt, Val* v, bool optional) const; // Recovers just one Val of possibly many; called from RecoverVals. @@ -51,8 +51,8 @@ protected: // Returns and updated kp for the next Val. Calls reporter->InternalError() // upon errors, so there is no return value for invalid input. const char* RecoverOneVal( - const zeek::detail::HashKey& k, const char* kp, const char* const k_end, - zeek::Type* t, zeek::ValPtr* pval, bool optional) const; + const HashKey& k, const char* kp, const char* const k_end, + Type* t, ValPtr* pval, bool optional) const; // Rounds the given pointer up to the nearest multiple of the // given size, if not already a multiple. @@ -88,14 +88,14 @@ protected: // the value is computed for the particular list of values. // Returns 0 if the key has an indeterminant size (if v not given), // or if v doesn't match the index type (if given). - int ComputeKeySize(const zeek::Val* v, bool type_check, + int ComputeKeySize(const Val* v, bool type_check, bool calc_static_size) const; - int SingleTypeKeySize(zeek::Type*, const zeek::Val*, + int SingleTypeKeySize(Type*, const Val*, bool type_check, int sz, bool optional, bool calc_static_size) const; - zeek::TypeListPtr type; + TypeListPtr type; char* key; // space for composite key int size; bool is_singleton; // if just one type in index @@ -103,7 +103,7 @@ protected: // If one type, but not normal "singleton", e.g. record. bool is_complex_type; - zeek::InternalTypeTag singleton_tag; + InternalTypeTag singleton_tag; }; } // namespace zeek::detail diff --git a/src/Conn.cc b/src/Conn.cc index 91cef11484..270575a986 100644 --- a/src/Conn.cc +++ b/src/Conn.cc @@ -25,7 +25,7 @@ namespace zeek { namespace detail { void ConnectionTimer::Init(Connection* arg_conn, timer_func arg_timer, - bool arg_do_expire) + bool arg_do_expire) { conn = arg_conn; timer = arg_timer; @@ -36,7 +36,7 @@ void ConnectionTimer::Init(Connection* arg_conn, timer_func arg_timer, ConnectionTimer::~ConnectionTimer() { if ( conn->RefCnt() < 1 ) - zeek::reporter->InternalError("reference count inconsistency in ~ConnectionTimer"); + reporter->InternalError("reference count inconsistency in ~ConnectionTimer"); conn->RemoveTimer(this); Unref(conn); @@ -54,7 +54,7 @@ void ConnectionTimer::Dispatch(double t, bool is_expire) (conn->*timer)(t); if ( conn->RefCnt() < 1 ) - zeek::reporter->InternalError("reference count inconsistency in ConnectionTimer::Dispatch"); + reporter->InternalError("reference count inconsistency in ConnectionTimer::Dispatch"); } } // namespace detail @@ -62,9 +62,9 @@ void ConnectionTimer::Dispatch(double t, bool is_expire) uint64_t Connection::total_connections = 0; uint64_t Connection::current_connections = 0; -Connection::Connection(zeek::NetSessions* s, const zeek::detail::ConnIDKey& k, double t, - const ConnID* id, uint32_t flow, const zeek::Packet* pkt, - const zeek::EncapsulationStack* arg_encap) +Connection::Connection(NetSessions* s, const detail::ConnIDKey& k, double t, + const ConnID* id, uint32_t flow, const Packet* pkt, + const EncapsulationStack* arg_encap) { sessions = s; key = k; @@ -122,7 +122,7 @@ Connection::Connection(zeek::NetSessions* s, const zeek::detail::ConnIDKey& k, d ++total_connections; if ( arg_encap ) - encapsulation = new zeek::EncapsulationStack(*arg_encap); + encapsulation = new EncapsulationStack(*arg_encap); else encapsulation = nullptr; } @@ -130,7 +130,7 @@ Connection::Connection(zeek::NetSessions* s, const zeek::detail::ConnIDKey& k, d Connection::~Connection() { if ( ! finished ) - zeek::reporter->InternalError("Done() not called before destruction of Connection"); + reporter->InternalError("Done() not called before destruction of Connection"); CancelTimers(); @@ -143,7 +143,7 @@ Connection::~Connection() --current_connections; } -void Connection::CheckEncapsulation(const zeek::EncapsulationStack* arg_encap) +void Connection::CheckEncapsulation(const EncapsulationStack* arg_encap) { if ( encapsulation && arg_encap ) { @@ -154,7 +154,7 @@ void Connection::CheckEncapsulation(const zeek::EncapsulationStack* arg_encap) arg_encap->ToVal()); delete encapsulation; - encapsulation = new zeek::EncapsulationStack(*arg_encap); + encapsulation = new EncapsulationStack(*arg_encap); } } @@ -162,7 +162,7 @@ void Connection::CheckEncapsulation(const zeek::EncapsulationStack* arg_encap) { if ( tunnel_changed ) { - zeek::EncapsulationStack empty; + EncapsulationStack empty; EnqueueEvent(tunnel_changed, nullptr, ConnVal(), empty.ToVal()); } @@ -175,7 +175,7 @@ void Connection::CheckEncapsulation(const zeek::EncapsulationStack* arg_encap) if ( tunnel_changed ) EnqueueEvent(tunnel_changed, nullptr, ConnVal(), arg_encap->ToVal()); - encapsulation = new zeek::EncapsulationStack(*arg_encap); + encapsulation = new EncapsulationStack(*arg_encap); } } @@ -188,14 +188,14 @@ void Connection::Done() } void Connection::NextPacket(double t, bool is_orig, - const zeek::IP_Hdr* ip, int len, int caplen, + const IP_Hdr* ip, int len, int caplen, const u_char*& data, int& record_packet, int& record_content, // arguments for reproducing packets - const zeek::Packet *pkt) + const Packet *pkt) { - zeek::run_state::current_timestamp = t; - zeek::run_state::current_pkt = pkt; + run_state::current_timestamp = t; + run_state::current_pkt = pkt; if ( Skipping() ) return; @@ -218,14 +218,14 @@ void Connection::NextPacket(double t, bool is_orig, else last_time = t; - zeek::run_state::current_timestamp = 0; - zeek::run_state::current_pkt = nullptr; + run_state::current_timestamp = 0; + run_state::current_pkt = nullptr; } void Connection::SetLifetime(double lifetime) { - ADD_TIMER(&Connection::DeleteTimer, zeek::run_state::network_time + lifetime, 0, - zeek::detail::TIMER_CONN_DELETE); + ADD_TIMER(&Connection::DeleteTimer, run_state::network_time + lifetime, 0, + detail::TIMER_CONN_DELETE); } bool Connection::IsReuse(double t, const u_char* pkt) @@ -258,7 +258,7 @@ bool Connection::ScaledHistoryEntry(char code, uint32_t& counter, return false; } -void Connection::HistoryThresholdEvent(zeek::EventHandlerPtr e, bool is_orig, +void Connection::HistoryThresholdEvent(EventHandlerPtr e, bool is_orig, uint32_t threshold) { if ( ! e ) @@ -271,8 +271,8 @@ void Connection::HistoryThresholdEvent(zeek::EventHandlerPtr e, bool is_orig, EnqueueEvent(e, nullptr, ConnVal(), - zeek::val_mgr->Bool(is_orig), - zeek::val_mgr->Count(threshold) + val_mgr->Bool(is_orig), + val_mgr->Count(threshold) ); } @@ -290,12 +290,12 @@ void Connection::InactivityTimer(double t) { Event(connection_timeout, nullptr); sessions->Remove(this); - ++zeek::detail::killed_by_inactivity; + ++detail::killed_by_inactivity; } else ADD_TIMER(&Connection::InactivityTimer, last_time + inactivity_timeout, 0, - zeek::detail::TIMER_CONN_INACTIVITY); + detail::TIMER_CONN_INACTIVITY); } void Connection::RemoveConnectionTimer(double t) @@ -311,15 +311,15 @@ void Connection::SetInactivityTimeout(double timeout) // First cancel and remove any existing inactivity timer. for ( const auto& timer : timers ) - if ( timer->Type() == zeek::detail::TIMER_CONN_INACTIVITY ) + if ( timer->Type() == detail::TIMER_CONN_INACTIVITY ) { - zeek::detail::timer_mgr->Cancel(timer); + detail::timer_mgr->Cancel(timer); break; } if ( timeout ) ADD_TIMER(&Connection::InactivityTimer, - last_time + timeout, 0, zeek::detail::TIMER_CONN_INACTIVITY); + last_time + timeout, 0, detail::TIMER_CONN_INACTIVITY); inactivity_timeout = timeout; } @@ -329,8 +329,8 @@ void Connection::EnableStatusUpdateTimer() if ( connection_status_update && zeek::detail::connection_status_update_interval ) { ADD_TIMER(&Connection::StatusUpdateTimer, - zeek::run_state::network_time + zeek::detail::connection_status_update_interval, 0, - zeek::detail::TIMER_CONN_STATUS_UPDATE); + run_state::network_time + detail::connection_status_update_interval, 0, + detail::TIMER_CONN_STATUS_UPDATE); installed_status_timer = 1; } } @@ -339,95 +339,95 @@ void Connection::StatusUpdateTimer(double t) { EnqueueEvent(connection_status_update, nullptr, ConnVal()); ADD_TIMER(&Connection::StatusUpdateTimer, - zeek::run_state::network_time + zeek::detail::connection_status_update_interval, 0, - zeek::detail::TIMER_CONN_STATUS_UPDATE); + run_state::network_time + detail::connection_status_update_interval, 0, + detail::TIMER_CONN_STATUS_UPDATE); } -zeek::RecordVal* Connection::BuildConnVal() +RecordVal* Connection::BuildConnVal() { return ConnVal()->Ref()->AsRecordVal(); } -const zeek::RecordValPtr& Connection::ConnVal() +const RecordValPtr& Connection::ConnVal() { if ( ! conn_val ) { - conn_val = zeek::make_intrusive(zeek::id::connection); + conn_val = make_intrusive(id::connection); TransportProto prot_type = ConnTransport(); - auto id_val = zeek::make_intrusive(zeek::id::conn_id); - id_val->Assign(0, zeek::make_intrusive(orig_addr)); - id_val->Assign(1, zeek::val_mgr->Port(ntohs(orig_port), prot_type)); - id_val->Assign(2, zeek::make_intrusive(resp_addr)); - id_val->Assign(3, zeek::val_mgr->Port(ntohs(resp_port), prot_type)); + auto id_val = make_intrusive(id::conn_id); + id_val->Assign(0, make_intrusive(orig_addr)); + id_val->Assign(1, val_mgr->Port(ntohs(orig_port), prot_type)); + id_val->Assign(2, make_intrusive(resp_addr)); + id_val->Assign(3, val_mgr->Port(ntohs(resp_port), prot_type)); - auto orig_endp = zeek::make_intrusive(zeek::id::endpoint); - orig_endp->Assign(0, zeek::val_mgr->Count(0)); - orig_endp->Assign(1, zeek::val_mgr->Count(0)); - orig_endp->Assign(4, zeek::val_mgr->Count(orig_flow_label)); + auto orig_endp = make_intrusive(id::endpoint); + orig_endp->Assign(0, val_mgr->Count(0)); + orig_endp->Assign(1, val_mgr->Count(0)); + orig_endp->Assign(4, val_mgr->Count(orig_flow_label)); const int l2_len = sizeof(orig_l2_addr); char null[l2_len]{}; if ( memcmp(&orig_l2_addr, &null, l2_len) != 0 ) - orig_endp->Assign(5, zeek::make_intrusive(fmt_mac(orig_l2_addr, l2_len))); + orig_endp->Assign(5, make_intrusive(fmt_mac(orig_l2_addr, l2_len))); - auto resp_endp = zeek::make_intrusive(zeek::id::endpoint); - resp_endp->Assign(0, zeek::val_mgr->Count(0)); - resp_endp->Assign(1, zeek::val_mgr->Count(0)); - resp_endp->Assign(4, zeek::val_mgr->Count(resp_flow_label)); + auto resp_endp = make_intrusive(id::endpoint); + resp_endp->Assign(0, val_mgr->Count(0)); + resp_endp->Assign(1, val_mgr->Count(0)); + resp_endp->Assign(4, val_mgr->Count(resp_flow_label)); if ( memcmp(&resp_l2_addr, &null, l2_len) != 0 ) - resp_endp->Assign(5, zeek::make_intrusive(fmt_mac(resp_l2_addr, l2_len))); + resp_endp->Assign(5, make_intrusive(fmt_mac(resp_l2_addr, l2_len))); conn_val->Assign(0, std::move(id_val)); conn_val->Assign(1, std::move(orig_endp)); conn_val->Assign(2, std::move(resp_endp)); // 3 and 4 are set below. - conn_val->Assign(5, zeek::make_intrusive(zeek::id::string_set)); // service - conn_val->Assign(6, zeek::val_mgr->EmptyString()); // history + conn_val->Assign(5, make_intrusive(id::string_set)); // service + conn_val->Assign(6, val_mgr->EmptyString()); // history if ( ! uid ) uid.Set(zeek::detail::bits_per_uid); - conn_val->Assign(7, zeek::make_intrusive(uid.Base62("C").c_str())); + conn_val->Assign(7, make_intrusive(uid.Base62("C").c_str())); if ( encapsulation && encapsulation->Depth() > 0 ) conn_val->Assign(8, encapsulation->ToVal()); if ( vlan != 0 ) - conn_val->Assign(9, zeek::val_mgr->Int(vlan)); + conn_val->Assign(9, val_mgr->Int(vlan)); if ( inner_vlan != 0 ) - conn_val->Assign(10, zeek::val_mgr->Int(inner_vlan)); + conn_val->Assign(10, val_mgr->Int(inner_vlan)); } if ( root_analyzer ) root_analyzer->UpdateConnVal(conn_val.get()); - conn_val->Assign(3, zeek::make_intrusive(start_time)); // ### - conn_val->Assign(4, zeek::make_intrusive(last_time - start_time)); - conn_val->Assign(6, zeek::make_intrusive(history.c_str())); - conn_val->Assign(11, zeek::val_mgr->Bool(is_successful)); + conn_val->Assign(3, make_intrusive(start_time)); // ### + conn_val->Assign(4, make_intrusive(last_time - start_time)); + conn_val->Assign(6, make_intrusive(history.c_str())); + conn_val->Assign(11, val_mgr->Bool(is_successful)); conn_val->SetOrigin(this); return conn_val; } -zeek::analyzer::Analyzer* Connection::FindAnalyzer(zeek::analyzer::ID id) +analyzer::Analyzer* Connection::FindAnalyzer(analyzer::ID id) { return root_analyzer ? root_analyzer->FindChild(id) : nullptr; } -zeek::analyzer::Analyzer* Connection::FindAnalyzer(const zeek::analyzer::Tag& tag) +analyzer::Analyzer* Connection::FindAnalyzer(const analyzer::Tag& tag) { return root_analyzer ? root_analyzer->FindChild(tag) : nullptr; } -zeek::analyzer::Analyzer* Connection::FindAnalyzer(const char* name) +analyzer::Analyzer* Connection::FindAnalyzer(const char* name) { return root_analyzer->FindChild(name); } @@ -439,7 +439,7 @@ void Connection::AppendAddl(const char* str) const char* old = cv->GetField(6)->AsString()->CheckString(); const char* format = *old ? "%s %s" : "%s%s"; - cv->Assign(6, zeek::make_intrusive(zeek::util::fmt(format, old, str))); + cv->Assign(6, make_intrusive(util::fmt(format, old, str))); } // Returns true if the character at s separates a version number. @@ -455,7 +455,7 @@ static inline bool is_version_sep(const char* s, const char* end) isspace(s[0]); } -void Connection::Match(zeek::detail::Rule::PatternType type, const u_char* data, int len, +void Connection::Match(detail::Rule::PatternType type, const u_char* data, int len, bool is_orig, bool bol, bool eol, bool clear_state) { if ( primary_PIA ) @@ -471,18 +471,18 @@ void Connection::RemovalEvent() EnqueueEvent(successful_connection_remove, nullptr, ConnVal()); } -void Connection::Event(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, const char* name) +void Connection::Event(EventHandlerPtr f, analyzer::Analyzer* analyzer, const char* name) { if ( ! f ) return; if ( name ) - EnqueueEvent(f, analyzer, zeek::make_intrusive(name), ConnVal()); + EnqueueEvent(f, analyzer, make_intrusive(name), ConnVal()); else EnqueueEvent(f, analyzer, ConnVal()); } -void Connection::Event(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, zeek::Val* v1, zeek::Val* v2) +void Connection::Event(EventHandlerPtr f, analyzer::Analyzer* analyzer, Val* v1, Val* v2) { if ( ! f ) { @@ -494,17 +494,17 @@ void Connection::Event(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyz if ( v2 ) EnqueueEvent(f, analyzer, ConnVal(), - zeek::IntrusivePtr{zeek::AdoptRef{}, v1}, - zeek::IntrusivePtr{zeek::AdoptRef{}, v2}); + IntrusivePtr{AdoptRef{}, v1}, + IntrusivePtr{AdoptRef{}, v2}); else EnqueueEvent(f, analyzer, ConnVal(), - zeek::IntrusivePtr{zeek::AdoptRef{}, v1}); + IntrusivePtr{AdoptRef{}, v1}); } -void Connection::ConnectionEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* a, ValPList vl) +void Connection::ConnectionEvent(EventHandlerPtr f, analyzer::Analyzer* a, ValPList vl) { - auto args = zeek::val_list_to_args(vl); + auto args = val_list_to_args(vl); if ( ! f ) // This may actually happen if there is no local handler @@ -512,40 +512,40 @@ void Connection::ConnectionEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyz return; // "this" is passed as a cookie for the event - zeek::event_mgr.Enqueue(f, std::move(args), zeek::util::detail::SOURCE_LOCAL, a ? a->GetID() : 0, this); + event_mgr.Enqueue(f, std::move(args), util::detail::SOURCE_LOCAL, a ? a->GetID() : 0, this); } -void Connection::ConnectionEventFast(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* a, ValPList vl) +void Connection::ConnectionEventFast(EventHandlerPtr f, analyzer::Analyzer* a, ValPList vl) { // "this" is passed as a cookie for the event - zeek::event_mgr.Enqueue(f, zeek::val_list_to_args(vl), zeek::util::detail::SOURCE_LOCAL, + event_mgr.Enqueue(f, val_list_to_args(vl), util::detail::SOURCE_LOCAL, a ? a->GetID() : 0, this); } -void Connection::ConnectionEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* a, ValPList* vl) +void Connection::ConnectionEvent(EventHandlerPtr f, analyzer::Analyzer* a, ValPList* vl) { - auto args = zeek::val_list_to_args(*vl); + auto args = val_list_to_args(*vl); delete vl; if ( f ) EnqueueEvent(f, a, std::move(args)); } -void Connection::EnqueueEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* a, - zeek::Args args) +void Connection::EnqueueEvent(EventHandlerPtr f, analyzer::Analyzer* a, + Args args) { // "this" is passed as a cookie for the event - zeek::event_mgr.Enqueue(f, std::move(args), zeek::util::detail::SOURCE_LOCAL, a ? a->GetID() : 0, this); + event_mgr.Enqueue(f, std::move(args), util::detail::SOURCE_LOCAL, a ? a->GetID() : 0, this); } void Connection::Weird(const char* name, const char* addl) { weird = 1; - zeek::reporter->Weird(this, name, addl ? addl : ""); + reporter->Weird(this, name, addl ? addl : ""); } void Connection::AddTimer(timer_func timer, double t, bool do_expire, - zeek::detail::TimerType type) + detail::TimerType type) { if ( timers_canceled ) return; @@ -556,12 +556,12 @@ void Connection::AddTimer(timer_func timer, double t, bool do_expire, if ( ! key_valid ) return; - zeek::detail::Timer* conn_timer = new detail::ConnectionTimer(this, timer, t, do_expire, type); - zeek::detail::timer_mgr->Add(conn_timer); + detail::Timer* conn_timer = new detail::ConnectionTimer(this, timer, t, do_expire, type); + detail::timer_mgr->Add(conn_timer); timers.push_back(conn_timer); } -void Connection::RemoveTimer(zeek::detail::Timer* t) +void Connection::RemoveTimer(detail::Timer* t) { timers.remove(t); } @@ -576,7 +576,7 @@ void Connection::CancelTimers() std::copy(timers.begin(), timers.end(), std::back_inserter(tmp)); for ( const auto& timer : tmp ) - zeek::detail::timer_mgr->Cancel(timer); + detail::timer_mgr->Cancel(timer); timers_canceled = 1; timers.clear(); @@ -584,7 +584,7 @@ void Connection::CancelTimers() void Connection::FlipRoles() { - zeek::IPAddr tmp_addr = resp_addr; + IPAddr tmp_addr = resp_addr; resp_addr = orig_addr; orig_addr = tmp_addr; @@ -611,7 +611,7 @@ void Connection::FlipRoles() if ( root_analyzer ) root_analyzer->FlipRoles(); - zeek::analyzer_mgr->ApplyScheduledAnalyzers(this); + analyzer_mgr->ApplyScheduledAnalyzers(this); AddHistory('^'); } @@ -632,7 +632,7 @@ unsigned int Connection::MemoryAllocationConnVal() const return conn_val ? conn_val->MemoryAllocation() : 0; } -void Connection::Describe(zeek::ODesc* d) const +void Connection::Describe(ODesc* d) const { d->Add(start_time); d->Add("("); @@ -654,13 +654,13 @@ void Connection::Describe(zeek::ODesc* d) const case TRANSPORT_UNKNOWN: d->Add("unknown"); - zeek::reporter->InternalWarning( + reporter->InternalWarning( "unknown transport in Connction::Describe()"); break; default: - zeek::reporter->InternalError( + reporter->InternalError( "unhandled transport type in Connection::Describe"); } @@ -679,7 +679,7 @@ void Connection::Describe(zeek::ODesc* d) const d->NL(); } -void Connection::IDString(zeek::ODesc* d) const +void Connection::IDString(ODesc* d) const { d->Add(orig_addr); d->AddRaw(":", 1); @@ -690,8 +690,8 @@ void Connection::IDString(zeek::ODesc* d) const d->Add(ntohs(resp_port)); } -void Connection::SetRootAnalyzer(zeek::analyzer::TransportLayerAnalyzer* analyzer, - zeek::analyzer::pia::PIA* pia) +void Connection::SetRootAnalyzer(analyzer::TransportLayerAnalyzer* analyzer, + analyzer::pia::PIA* pia) { root_analyzer = analyzer; primary_PIA = pia; @@ -705,8 +705,8 @@ void Connection::CheckFlowLabel(bool is_orig, uint32_t flow_label) { if ( conn_val ) { - zeek::RecordVal* endp = conn_val->GetField(is_orig ? 1 : 2)->AsRecordVal(); - endp->Assign(4, zeek::val_mgr->Count(flow_label)); + RecordVal* endp = conn_val->GetField(is_orig ? 1 : 2)->AsRecordVal(); + endp->Assign(4, val_mgr->Count(flow_label)); } if ( connection_flow_label_changed && @@ -714,9 +714,9 @@ void Connection::CheckFlowLabel(bool is_orig, uint32_t flow_label) { EnqueueEvent(connection_flow_label_changed, nullptr, ConnVal(), - zeek::val_mgr->Bool(is_orig), - zeek::val_mgr->Count(my_flow_label), - zeek::val_mgr->Count(flow_label) + val_mgr->Bool(is_orig), + val_mgr->Count(my_flow_label), + val_mgr->Count(flow_label) ); } @@ -732,7 +732,7 @@ void Connection::CheckFlowLabel(bool is_orig, uint32_t flow_label) bool Connection::PermitWeird(const char* name, uint64_t threshold, uint64_t rate, double duration) { - return zeek::detail::PermitWeird(weird_state, name, threshold, rate, duration); + return detail::PermitWeird(weird_state, name, threshold, rate, duration); } } // namespace zeek diff --git a/src/Conn.h b/src/Conn.h index 3081e77f0c..dc9ebc3acb 100644 --- a/src/Conn.h +++ b/src/Conn.h @@ -36,8 +36,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(TransportLayerAnalyzer, zeek, analyzer); ZEEK_FORWARD_DECLARE_NAMESPACED(Analyzer, zeek, analyzer); namespace zeek { -using ValPtr = zeek::IntrusivePtr; -using RecordValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; +using RecordValPtr = IntrusivePtr; enum ConnEventToFlag { NUL_IN_LINE, @@ -49,23 +49,23 @@ enum ConnEventToFlag { typedef void (Connection::*timer_func)(double t); struct ConnID { - zeek::IPAddr src_addr; - zeek::IPAddr dst_addr; + IPAddr src_addr; + IPAddr dst_addr; uint32_t src_port; uint32_t dst_port; bool is_one_way; // if true, don't canonicalize order }; -static inline int addr_port_canon_lt(const zeek::IPAddr& addr1, uint32_t p1, - const zeek::IPAddr& addr2, uint32_t p2) +static inline int addr_port_canon_lt(const IPAddr& addr1, uint32_t p1, + const IPAddr& addr2, uint32_t p2) { return addr1 < addr2 || (addr1 == addr2 && p1 < p2); } -class Connection final : public zeek::Obj { +class Connection final : public Obj { public: - Connection(zeek::NetSessions* s, const zeek::detail::ConnIDKey& k, double t, const ConnID* id, - uint32_t flow, const zeek::Packet* pkt, const zeek::EncapsulationStack* arg_encap); + Connection(NetSessions* s, const detail::ConnIDKey& k, double t, const ConnID* id, + uint32_t flow, const Packet* pkt, const EncapsulationStack* arg_encap); ~Connection() override; // Invoked when an encapsulation is discovered. It records the @@ -73,7 +73,7 @@ public: // event if it's different from the previous encapsulation (or the // first encountered). encap can be null to indicate no // encapsulation. - void CheckEncapsulation(const zeek::EncapsulationStack* encap); + void CheckEncapsulation(const EncapsulationStack* encap); // Invoked when connection is about to be removed. Use Ref(this) // inside Done to keep the connection object around (though it'll @@ -91,16 +91,16 @@ public: // be recorded, otherwise just up through the transport header. // Both are assumed set to true when called. void NextPacket(double t, bool is_orig, - const zeek::IP_Hdr* ip, int len, int caplen, + const IP_Hdr* ip, int len, int caplen, const u_char*& data, int& record_packet, int& record_content, // arguments for reproducing packets - const zeek::Packet *pkt); + const Packet *pkt); // Keys are only considered valid for a connection when a // connection is in the session map. If it is removed, the key // should be marked invalid. - const zeek::detail::ConnIDKey& Key() const { return key; } + const detail::ConnIDKey& Key() const { return key; } void ClearKey() { key_valid = false; } bool IsKeyValid() const { return key_valid; } @@ -109,17 +109,17 @@ public: double LastTime() const { return last_time; } void SetLastTime(double t) { last_time = t; } - const zeek::IPAddr& OrigAddr() const { return orig_addr; } - const zeek::IPAddr& RespAddr() const { return resp_addr; } + const IPAddr& OrigAddr() const { return orig_addr; } + const IPAddr& RespAddr() const { return resp_addr; } uint32_t OrigPort() const { return orig_port; } uint32_t RespPort() const { return resp_port; } void FlipRoles(); - zeek::analyzer::Analyzer* FindAnalyzer(zeek::analyzer::ID id); - zeek::analyzer::Analyzer* FindAnalyzer(const zeek::analyzer::Tag& tag); // find first in tree. - zeek::analyzer::Analyzer* FindAnalyzer(const char* name); // find first in tree. + analyzer::Analyzer* FindAnalyzer(analyzer::ID id); + analyzer::Analyzer* FindAnalyzer(const analyzer::Tag& tag); // find first in tree. + analyzer::Analyzer* FindAnalyzer(const char* name); // find first in tree. TransportProto ConnTransport() const { return proto; } @@ -167,18 +167,18 @@ public: void EnableStatusUpdateTimer(); [[deprecated("Remove in v4.1. Use ConnVal() instead.")]] - zeek::RecordVal* BuildConnVal(); + RecordVal* BuildConnVal(); /** * Returns the associated "connection" record. */ - const zeek::RecordValPtr& ConnVal(); + const RecordValPtr& ConnVal(); void AppendAddl(const char* str); LoginConn* AsLoginConn() { return login_conn; } - void Match(zeek::detail::Rule::PatternType type, const u_char* data, int len, + void Match(detail::Rule::PatternType type, const u_char* data, int len, bool is_orig, bool bol, bool eol, bool clear_state); /** @@ -190,29 +190,27 @@ public: // given that event's first argument will be it, and it's second will be // the connection value. If 'name' is null, then the event's first // argument is the connection value. - void Event(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, const char* name = nullptr); + void Event(EventHandlerPtr f, analyzer::Analyzer* analyzer, const char* name = nullptr); // If a handler exists for 'f', an event will be generated. In any case, // 'v1' and 'v2' reference counts get decremented. The event's first // argument is the connection value, second argument is 'v1', and if 'v2' // is given that will be it's third argument. [[deprecated("Remove in v4.1. Use EnqueueEvent() instead (note it doesn't automatically add the connection argument).")]] - void Event(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, zeek::Val* v1, zeek::Val* v2 = nullptr); + void Event(EventHandlerPtr f, analyzer::Analyzer* analyzer, Val* v1, Val* v2 = nullptr); // If a handler exists for 'f', an event will be generated. In any case, // reference count for each element in the 'vl' list are decremented. The // arguments used for the event are whatevever is provided in 'vl'. [[deprecated("Remove in v4.1. Use EnqueueEvent() instead.")]] - void ConnectionEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, - ValPList vl); + void ConnectionEvent(EventHandlerPtr f, analyzer::Analyzer* analyzer, ValPList vl); // Same as ConnectionEvent, except taking the event's argument list via a // pointer instead of by value. This function takes ownership of the // memory pointed to by 'vl' and also for decrementing the reference count // of each of its elements. [[deprecated("Remove in v4.1. Use EnqueueEvent() instead.")]] - void ConnectionEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, - ValPList* vl); + void ConnectionEvent(EventHandlerPtr f, analyzer::Analyzer* analyzer, ValPList* vl); // Queues an event without first checking if there's any available event // handlers (or remote consumes). If it turns out there's actually nothing @@ -229,8 +227,8 @@ public: /** * Enqueues an event associated with this connection and given analyzer. */ - void EnqueueEvent(zeek::EventHandlerPtr f, zeek::analyzer::Analyzer* analyzer, - zeek::Args args); + void EnqueueEvent(EventHandlerPtr f, analyzer::Analyzer* analyzer, + Args args); /** * A version of EnqueueEvent() taking a variable number of arguments. @@ -238,8 +236,8 @@ public: template std::enable_if_t< std::is_convertible_v< - std::tuple_element_t<0, std::tuple>, zeek::ValPtr>> - EnqueueEvent(zeek::EventHandlerPtr h, zeek::analyzer::Analyzer* analyzer, Args&&... args) + std::tuple_element_t<0, std::tuple>, ValPtr>> + EnqueueEvent(EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args) { return EnqueueEvent(h, analyzer, zeek::Args{std::forward(args)...}); } void Weird(const char* name, const char* addl = ""); @@ -260,8 +258,8 @@ public: return true; } - void Describe(zeek::ODesc* d) const override; - void IDString(zeek::ODesc* d) const; + void Describe(ODesc* d) const override; + void IDString(ODesc* d) const; // Statistics. @@ -295,7 +293,7 @@ public: uint32_t& scaling_threshold, uint32_t scaling_base = 10); - void HistoryThresholdEvent(zeek::EventHandlerPtr e, bool is_orig, + void HistoryThresholdEvent(EventHandlerPtr e, bool is_orig, uint32_t threshold); void AddHistory(char code) { history += code; } @@ -303,18 +301,18 @@ public: void DeleteTimer(double t); // Sets the root of the analyzer tree as well as the primary PIA. - void SetRootAnalyzer(zeek::analyzer::TransportLayerAnalyzer* analyzer, zeek::analyzer::pia::PIA* pia); - zeek::analyzer::TransportLayerAnalyzer* GetRootAnalyzer() { return root_analyzer; } - zeek::analyzer::pia::PIA* GetPrimaryPIA() { return primary_PIA; } + void SetRootAnalyzer(analyzer::TransportLayerAnalyzer* analyzer, analyzer::pia::PIA* pia); + analyzer::TransportLayerAnalyzer* GetRootAnalyzer() { return root_analyzer; } + analyzer::pia::PIA* GetPrimaryPIA() { return primary_PIA; } // Sets the transport protocol in use. void SetTransport(TransportProto arg_proto) { proto = arg_proto; } - void SetUID(const zeek::UID &arg_uid) { uid = arg_uid; } + void SetUID(const UID &arg_uid) { uid = arg_uid; } - zeek::UID GetUID() const { return uid; } + UID GetUID() const { return uid; } - const zeek::EncapsulationStack* GetEncapsulation() const + const EncapsulationStack* GetEncapsulation() const { return encapsulation; } void CheckFlowLabel(bool is_orig, uint32_t flow_label); @@ -331,9 +329,9 @@ protected: // is true, then the timer is also evaluated when Bro terminates, // otherwise not. void AddTimer(timer_func timer, double t, bool do_expire, - zeek::detail::TimerType type); + detail::TimerType type); - void RemoveTimer(zeek::detail::Timer* t); + void RemoveTimer(detail::Timer* t); // Allow other classes to access pointers to these: friend class detail::ConnectionTimer; @@ -342,25 +340,25 @@ protected: void StatusUpdateTimer(double t); void RemoveConnectionTimer(double t); - zeek::NetSessions* sessions; - zeek::detail::ConnIDKey key; + NetSessions* sessions; + detail::ConnIDKey key; bool key_valid; TimerPList timers; - zeek::IPAddr orig_addr; - zeek::IPAddr resp_addr; + IPAddr orig_addr; + IPAddr resp_addr; uint32_t orig_port, resp_port; // in network order TransportProto proto; uint32_t orig_flow_label, resp_flow_label; // most recent IPv6 flow labels uint32_t vlan, inner_vlan; // VLAN this connection traverses, if available - u_char orig_l2_addr[zeek::Packet::l2_addr_len]; // Link-layer originator address, if available - u_char resp_l2_addr[zeek::Packet::l2_addr_len]; // Link-layer responder address, if available + u_char orig_l2_addr[Packet::l2_addr_len]; // Link-layer originator address, if available + u_char resp_l2_addr[Packet::l2_addr_len]; // Link-layer responder address, if available double start_time, last_time; double inactivity_timeout; - zeek::RecordValPtr conn_val; + RecordValPtr conn_val; LoginConn* login_conn; // either nil, or this - const zeek::EncapsulationStack* encapsulation; // tunnels + const EncapsulationStack* encapsulation; // tunnels int suppress_event; // suppress certain events to once per conn. unsigned int installed_status_timer:1; @@ -381,20 +379,20 @@ protected: std::string history; uint32_t hist_seen; - zeek::analyzer::TransportLayerAnalyzer* root_analyzer; - zeek::analyzer::pia::PIA* primary_PIA; + analyzer::TransportLayerAnalyzer* root_analyzer; + analyzer::pia::PIA* primary_PIA; - zeek::UID uid; // Globally unique connection ID. - zeek::detail::WeirdStateMap weird_state; + UID uid; // Globally unique connection ID. + detail::WeirdStateMap weird_state; }; namespace detail { -class ConnectionTimer final : public zeek::detail::Timer { +class ConnectionTimer final : public Timer { public: ConnectionTimer(Connection* arg_conn, timer_func arg_timer, - double arg_t, bool arg_do_expire, zeek::detail::TimerType arg_type) - : zeek::detail::Timer(arg_t, arg_type) + double arg_t, bool arg_do_expire, TimerType arg_type) + : Timer(arg_t, arg_type) { Init(arg_conn, arg_timer, arg_do_expire); } ~ConnectionTimer() override; diff --git a/src/DFA.cc b/src/DFA.cc index 09aed30c25..cf72f7ec80 100644 --- a/src/DFA.cc +++ b/src/DFA.cc @@ -284,9 +284,9 @@ void DFA_State::Stats(unsigned int* computed, unsigned int* uncomputed) unsigned int DFA_State::Size() { return sizeof(*this) - + zeek::util::pad_size(sizeof(DFA_State*) * num_sym) - + (accept ? zeek::util::pad_size(sizeof(int) * accept->size()) : 0) - + (nfa_states ? zeek::util::pad_size(sizeof(NFA_State*) * nfa_states->length()) : 0) + + util::pad_size(sizeof(DFA_State*) * num_sym) + + (accept ? util::pad_size(sizeof(int) * accept->size()) : 0) + + (nfa_states ? util::pad_size(sizeof(NFA_State*) * nfa_states->length()) : 0) + (meta_ec ? meta_ec->Size() : 0); } @@ -373,7 +373,7 @@ void DFA_State_Cache::GetStats(Stats* s) ++s->dfa_states; s->nfa_states += e->NFAStateNum(); e->Stats(&s->computed, &s->uncomputed); - s->mem += zeek::util::pad_size(e->Size()) + padded_sizeof(*e); + s->mem += util::pad_size(e->Size()) + padded_sizeof(*e); } } diff --git a/src/DFA.h b/src/DFA.h index a3fecb0780..20064794db 100644 --- a/src/DFA.h +++ b/src/DFA.h @@ -23,7 +23,7 @@ class DFA_Machine; #define DFA_UNCOMPUTED_STATE -2 #define DFA_UNCOMPUTED_STATE_PTR ((DFA_State*) DFA_UNCOMPUTED_STATE) -class DFA_State : public zeek::Obj { +class DFA_State : public Obj { public: DFA_State(int state_num, const EquivClass* ec, NFA_state_list* nfa_states, AcceptingSet* accept); @@ -108,7 +108,7 @@ private: std::map states; }; -class DFA_Machine : public zeek::Obj { +class DFA_Machine : public Obj { public: DFA_Machine(NFA_Machine* n, EquivClass* ec); ~DFA_Machine() override; diff --git a/src/DNS_Mgr.cc b/src/DNS_Mgr.cc index 43f0917749..c3f295795e 100644 --- a/src/DNS_Mgr.cc +++ b/src/DNS_Mgr.cc @@ -58,11 +58,11 @@ namespace zeek::detail { class DNS_Mgr_Request { public: DNS_Mgr_Request(const char* h, int af, bool is_txt) - : host(zeek::util::copy_string(h)), fam(af), qtype(is_txt ? 16 : 0), addr(), + : host(util::copy_string(h)), fam(af), qtype(is_txt ? 16 : 0), addr(), request_pending() { } - DNS_Mgr_Request(const zeek::IPAddr& a) + DNS_Mgr_Request(const IPAddr& a) : host(), fam(), qtype(), addr(a), request_pending() { } @@ -70,7 +70,7 @@ public: // Returns nil if this was an address request. const char* ReqHost() const { return host; } - const zeek::IPAddr& ReqAddr() const { return addr; } + const IPAddr& ReqAddr() const { return addr; } bool ReqIsTxt() const { return qtype == 16; } int MakeRequest(nb_dns_info* nb_dns); @@ -82,7 +82,7 @@ protected: char* host; // if non-nil, this is a host request int fam; // address family query type for host requests int qtype; // Query type - zeek::IPAddr addr; + IPAddr addr; int request_pending; }; @@ -108,7 +108,7 @@ int DNS_Mgr_Request::MakeRequest(nb_dns_info* nb_dns) class DNS_Mapping { public: DNS_Mapping(const char* host, struct hostent* h, uint32_t ttl); - DNS_Mapping(const zeek::IPAddr& addr, struct hostent* h, uint32_t ttl); + DNS_Mapping(const IPAddr& addr, struct hostent* h, uint32_t ttl); DNS_Mapping(FILE* f); bool NoMapping() const { return no_mapping; } @@ -118,15 +118,15 @@ public: // Returns nil if this was an address request. const char* ReqHost() const { return req_host; } - zeek::IPAddr ReqAddr() const { return req_addr; } + IPAddr ReqAddr() const { return req_addr; } string ReqStr() const { return req_host ? req_host : req_addr.AsString(); } - zeek::ListValPtr Addrs(); - zeek::TableValPtr AddrsSet(); // addresses returned as a set - zeek::StringValPtr Host(); + ListValPtr Addrs(); + TableValPtr AddrsSet(); // addresses returned as a set + StringValPtr Host(); double CreationTime() const { return creation_time; } @@ -140,7 +140,7 @@ public: if ( req_host && num_addrs == 0) return false; // nothing to expire - return zeek::util::current_time() > (creation_time + req_ttl); + return util::current_time() > (creation_time + req_ttl); } int Type() const { return map_type; } @@ -152,16 +152,16 @@ protected: void Clear(); char* req_host; - zeek::IPAddr req_addr; + IPAddr req_addr; uint32_t req_ttl; int num_names; char** names; - zeek::StringValPtr host_val; + StringValPtr host_val; int num_addrs; - zeek::IPAddr* addrs; - zeek::ListValPtr addrs_val; + IPAddr* addrs; + ListValPtr addrs_val; double creation_time; int map_type; @@ -175,26 +175,26 @@ void DNS_Mgr_mapping_delete_func(void* v) delete (DNS_Mapping*) v; } -static zeek::TableValPtr empty_addr_set() +static TableValPtr empty_addr_set() { - auto addr_t = zeek::base_type(zeek::TYPE_ADDR); - auto set_index = zeek::make_intrusive(addr_t); + auto addr_t = base_type(TYPE_ADDR); + auto set_index = make_intrusive(addr_t); set_index->Append(std::move(addr_t)); - auto s = zeek::make_intrusive(std::move(set_index), nullptr); - return zeek::make_intrusive(std::move(s)); + auto s = make_intrusive(std::move(set_index), nullptr); + return make_intrusive(std::move(s)); } DNS_Mapping::DNS_Mapping(const char* host, struct hostent* h, uint32_t ttl) { Init(h); - req_host = zeek::util::copy_string(host); + req_host = util::copy_string(host); req_ttl = ttl; if ( names && ! names[0] ) - names[0] = zeek::util::copy_string(host); + names[0] = util::copy_string(host); } -DNS_Mapping::DNS_Mapping(const zeek::IPAddr& addr, struct hostent* h, uint32_t ttl) +DNS_Mapping::DNS_Mapping(const IPAddr& addr, struct hostent* h, uint32_t ttl) { Init(h); req_addr = addr; @@ -231,17 +231,17 @@ DNS_Mapping::DNS_Mapping(FILE* f) failed = static_cast(failed_local); if ( is_req_host ) - req_host = zeek::util::copy_string(req_buf); + req_host = util::copy_string(req_buf); else - req_addr = zeek::IPAddr(req_buf); + req_addr = IPAddr(req_buf); num_names = 1; names = new char*[num_names]; - names[0] = zeek::util::copy_string(name_buf); + names[0] = util::copy_string(name_buf); if ( num_addrs > 0 ) { - addrs = new zeek::IPAddr[num_addrs]; + addrs = new IPAddr[num_addrs]; for ( int i = 0; i < num_addrs; ++i ) { @@ -255,7 +255,7 @@ DNS_Mapping::DNS_Mapping(FILE* f) if ( newline ) *newline = '\0'; - addrs[i] = zeek::IPAddr(buf); + addrs[i] = IPAddr(buf); } } else @@ -278,23 +278,23 @@ DNS_Mapping::~DNS_Mapping() delete [] addrs; } -zeek::ListValPtr DNS_Mapping::Addrs() +ListValPtr DNS_Mapping::Addrs() { if ( failed ) return nullptr; if ( ! addrs_val ) { - addrs_val = zeek::make_intrusive(zeek::TYPE_ADDR); + addrs_val = make_intrusive(TYPE_ADDR); for ( int i = 0; i < num_addrs; ++i ) - addrs_val->Append(zeek::make_intrusive(addrs[i])); + addrs_val->Append(make_intrusive(addrs[i])); } return addrs_val; } -zeek::TableValPtr DNS_Mapping::AddrsSet() { +TableValPtr DNS_Mapping::AddrsSet() { auto l = Addrs(); if ( ! l ) @@ -303,13 +303,13 @@ zeek::TableValPtr DNS_Mapping::AddrsSet() { return l->ToSetVal(); } -zeek::StringValPtr DNS_Mapping::Host() +StringValPtr DNS_Mapping::Host() { if ( failed || num_names == 0 || ! names[0] ) return nullptr; if ( ! host_val ) - host_val = zeek::make_intrusive(names[0]); + host_val = make_intrusive(names[0]); return host_val; } @@ -318,7 +318,7 @@ void DNS_Mapping::Init(struct hostent* h) { no_mapping = false; init_failed = false; - creation_time = zeek::util::current_time(); + creation_time = util::current_time(); host_val = nullptr; addrs_val = nullptr; @@ -331,21 +331,21 @@ void DNS_Mapping::Init(struct hostent* h) map_type = h->h_addrtype; num_names = 1; // for now, just use official name names = new char*[num_names]; - names[0] = h->h_name ? zeek::util::copy_string(h->h_name) : nullptr; + names[0] = h->h_name ? util::copy_string(h->h_name) : nullptr; for ( num_addrs = 0; h->h_addr_list[num_addrs]; ++num_addrs ) ; if ( num_addrs > 0 ) { - addrs = new zeek::IPAddr[num_addrs]; + addrs = new IPAddr[num_addrs]; for ( int i = 0; i < num_addrs; ++i ) if ( h->h_addrtype == AF_INET ) - addrs[i] = zeek::IPAddr(IPv4, (uint32_t*)h->h_addr_list[i], - zeek::IPAddr::Network); + addrs[i] = IPAddr(IPv4, (uint32_t*)h->h_addr_list[i], + IPAddr::Network); else if ( h->h_addrtype == AF_INET6 ) - addrs[i] = zeek::IPAddr(IPv6, (uint32_t*)h->h_addr_list[i], - zeek::IPAddr::Network); + addrs[i] = IPAddr(IPv6, (uint32_t*)h->h_addr_list[i], + IPAddr::Network); } else addrs = nullptr; @@ -411,11 +411,11 @@ void DNS_Mgr::InitSource() // script-layer option to configure the DNS resolver as it may not be // configured to the user's desired address at the time when we need to to // the lookup. - auto dns_resolver = zeek::util::zeekenv("ZEEK_DNS_RESOLVER"); - auto dns_resolver_addr = dns_resolver ? zeek::IPAddr(dns_resolver) : zeek::IPAddr(); + auto dns_resolver = util::zeekenv("ZEEK_DNS_RESOLVER"); + auto dns_resolver_addr = dns_resolver ? IPAddr(dns_resolver) : IPAddr(); char err[NB_DNS_ERRSIZE]; - if ( dns_resolver_addr == zeek::IPAddr() ) + if ( dns_resolver_addr == IPAddr() ) nb_dns = nb_dns_init(err); else { @@ -439,12 +439,12 @@ void DNS_Mgr::InitSource() if ( nb_dns ) { - if ( ! zeek::iosource_mgr->RegisterFd(nb_dns_fd(nb_dns), this) ) - zeek::reporter->FatalError("Failed to register nb_dns file descriptor with iosource_mgr"); + if ( ! iosource_mgr->RegisterFd(nb_dns_fd(nb_dns), this) ) + reporter->FatalError("Failed to register nb_dns file descriptor with iosource_mgr"); } else { - zeek::reporter->Warning("problem initializing NB-DNS: %s", err); + reporter->Warning("problem initializing NB-DNS: %s", err); } did_init = true; @@ -452,10 +452,10 @@ void DNS_Mgr::InitSource() void DNS_Mgr::InitPostScript() { - dm_rec = zeek::id::find_type("dns_mapping"); + dm_rec = id::find_type("dns_mapping"); // Registering will call Init() - zeek::iosource_mgr->Register(this, true); + iosource_mgr->Register(this, true); const char* cache_dir = dir ? dir : "."; cache_name = new char[strlen(cache_dir) + 64]; @@ -463,12 +463,12 @@ void DNS_Mgr::InitPostScript() LoadCache(fopen(cache_name, "r")); } -static zeek::TableValPtr fake_name_lookup_result(const char* name) +static TableValPtr fake_name_lookup_result(const char* name) { hash128_t hash; KeyedHash::StaticHash128(name, strlen(name), &hash); - auto hv = zeek::make_intrusive(zeek::TYPE_ADDR); - hv->Append(zeek::make_intrusive(reinterpret_cast(&hash))); + auto hv = make_intrusive(TYPE_ADDR); + hv->Append(make_intrusive(reinterpret_cast(&hash))); return hv->ToSetVal(); } @@ -479,7 +479,7 @@ static const char* fake_text_lookup_result(const char* name) return tmp; } -static const char* fake_addr_lookup_result(const zeek::IPAddr& addr) +static const char* fake_addr_lookup_result(const IPAddr& addr) { static char tmp[128]; snprintf(tmp, sizeof(tmp), "fake_addr_lookup_result_%s", @@ -487,7 +487,7 @@ static const char* fake_addr_lookup_result(const zeek::IPAddr& addr) return tmp; } -zeek::TableValPtr DNS_Mgr::LookupHost(const char* name) +TableValPtr DNS_Mgr::LookupHost(const char* name) { if ( mode == DNS_FAKE ) return fake_name_lookup_result(name); @@ -508,7 +508,7 @@ zeek::TableValPtr DNS_Mgr::LookupHost(const char* name) if ( (d4 && d4->Failed()) || (d6 && d6->Failed()) ) { - zeek::reporter->Warning("no such host: %s", name); + reporter->Warning("no such host: %s", name); return empty_addr_set(); } else if ( d4 && d6 ) @@ -529,7 +529,7 @@ zeek::TableValPtr DNS_Mgr::LookupHost(const char* name) return empty_addr_set(); case DNS_FORCE: - zeek::reporter->FatalError("can't find DNS entry for %s in cache", name); + reporter->FatalError("can't find DNS entry for %s in cache", name); return nullptr; case DNS_DEFAULT: @@ -539,12 +539,12 @@ zeek::TableValPtr DNS_Mgr::LookupHost(const char* name) return LookupHost(name); default: - zeek::reporter->InternalError("bad mode in DNS_Mgr::LookupHost"); + reporter->InternalError("bad mode in DNS_Mgr::LookupHost"); return nullptr; } } -zeek::ValPtr DNS_Mgr::LookupAddr(const zeek::IPAddr& addr) +ValPtr DNS_Mgr::LookupAddr(const IPAddr& addr) { InitSource(); @@ -560,8 +560,8 @@ zeek::ValPtr DNS_Mgr::LookupAddr(const zeek::IPAddr& addr) else { string s(addr); - zeek::reporter->Warning("can't resolve IP address: %s", s.c_str()); - return zeek::make_intrusive(s.c_str()); + reporter->Warning("can't resolve IP address: %s", s.c_str()); + return make_intrusive(s.c_str()); } } } @@ -570,10 +570,10 @@ zeek::ValPtr DNS_Mgr::LookupAddr(const zeek::IPAddr& addr) switch ( mode ) { case DNS_PRIME: requests.push_back(new DNS_Mgr_Request(addr)); - return zeek::make_intrusive(""); + return make_intrusive(""); case DNS_FORCE: - zeek::reporter->FatalError("can't find DNS entry for %s in cache", + reporter->FatalError("can't find DNS entry for %s in cache", addr.AsString().c_str()); return nullptr; @@ -583,7 +583,7 @@ zeek::ValPtr DNS_Mgr::LookupAddr(const zeek::IPAddr& addr) return LookupAddr(addr); default: - zeek::reporter->InternalError("bad mode in DNS_Mgr::LookupAddr"); + reporter->InternalError("bad mode in DNS_Mgr::LookupAddr"); return nullptr; } } @@ -644,7 +644,7 @@ void DNS_Mgr::Resolve() struct nb_dns_result r; status = nb_dns_activity(nb_dns, &r, err); if ( status < 0 ) - zeek::reporter->Warning( + reporter->Warning( "NB-DNS error in DNS_Mgr::WaitForReplies (%s)", err); else if ( status > 0 ) @@ -696,16 +696,16 @@ void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* dm) if ( ! e ) return; - zeek::event_mgr.Enqueue(e, BuildMappingVal(dm)); + event_mgr.Enqueue(e, BuildMappingVal(dm)); } void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* dm, - zeek::ListValPtr l1, zeek::ListValPtr l2) + ListValPtr l1, ListValPtr l2) { if ( ! e ) return; - zeek::event_mgr.Enqueue(e, BuildMappingVal(dm), l1->ToSetVal(), l2->ToSetVal()); + event_mgr.Enqueue(e, BuildMappingVal(dm), l1->ToSetVal(), l2->ToSetVal()); } void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm) @@ -713,20 +713,20 @@ void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm) if ( ! e ) return; - zeek::event_mgr.Enqueue(e, BuildMappingVal(old_dm), BuildMappingVal(new_dm)); + event_mgr.Enqueue(e, BuildMappingVal(old_dm), BuildMappingVal(new_dm)); } -zeek::ValPtr DNS_Mgr::BuildMappingVal(DNS_Mapping* dm) +ValPtr DNS_Mgr::BuildMappingVal(DNS_Mapping* dm) { - auto r = zeek::make_intrusive(dm_rec); + auto r = make_intrusive(dm_rec); - r->Assign(0, zeek::make_intrusive(dm->CreationTime())); - r->Assign(1, zeek::make_intrusive(dm->ReqHost() ? dm->ReqHost() : "")); - r->Assign(2, zeek::make_intrusive(dm->ReqAddr())); - r->Assign(3, zeek::val_mgr->Bool(dm->Valid())); + r->Assign(0, make_intrusive(dm->CreationTime())); + r->Assign(1, make_intrusive(dm->ReqHost() ? dm->ReqHost() : "")); + r->Assign(2, make_intrusive(dm->ReqAddr())); + r->Assign(3, val_mgr->Bool(dm->Valid())); auto h = dm->Host(); - r->Assign(4, h ? std::move(h) : zeek::make_intrusive("")); + r->Assign(4, h ? std::move(h) : make_intrusive("")); r->Assign(5, dm->AddrsSet()); return r; @@ -861,7 +861,7 @@ void DNS_Mgr::CompareMappings(DNS_Mapping* prev_dm, DNS_Mapping* new_dm) if ( ! prev_a || ! new_a ) { - zeek::reporter->InternalWarning("confused in DNS_Mgr::CompareMappings"); + reporter->InternalWarning("confused in DNS_Mgr::CompareMappings"); return; } @@ -872,18 +872,18 @@ void DNS_Mgr::CompareMappings(DNS_Mapping* prev_dm, DNS_Mapping* new_dm) Event(dns_mapping_altered, new_dm, std::move(prev_delta), std::move(new_delta)); } -zeek::ListValPtr DNS_Mgr::AddrListDelta(zeek::ListVal* al1, zeek::ListVal* al2) +ListValPtr DNS_Mgr::AddrListDelta(ListVal* al1, ListVal* al2) { - auto delta = zeek::make_intrusive(zeek::TYPE_ADDR); + auto delta = make_intrusive(TYPE_ADDR); for ( int i = 0; i < al1->Length(); ++i ) { - const zeek::IPAddr& al1_i = al1->Idx(i)->AsAddr(); + const IPAddr& al1_i = al1->Idx(i)->AsAddr(); int j; for ( j = 0; j < al2->Length(); ++j ) { - const zeek::IPAddr& al2_j = al2->Idx(j)->AsAddr(); + const IPAddr& al2_j = al2->Idx(j)->AsAddr(); if ( al1_i == al2_j ) break; } @@ -896,11 +896,11 @@ zeek::ListValPtr DNS_Mgr::AddrListDelta(zeek::ListVal* al1, zeek::ListVal* al2) return delta; } -void DNS_Mgr::DumpAddrList(FILE* f, zeek::ListVal* al) +void DNS_Mgr::DumpAddrList(FILE* f, ListVal* al) { for ( int i = 0; i < al->Length(); ++i ) { - const zeek::IPAddr& al_i = al->Idx(i)->AsAddr(); + const IPAddr& al_i = al->Idx(i)->AsAddr(); fprintf(f, "%s%s", i > 0 ? "," : "", al_i.AsString().c_str()); } } @@ -932,7 +932,7 @@ void DNS_Mgr::LoadCache(FILE* f) } if ( ! m->NoMapping() ) - zeek::reporter->FatalError("DNS cache corrupted"); + reporter->FatalError("DNS cache corrupted"); delete m; fclose(f); @@ -961,7 +961,7 @@ void DNS_Mgr::Save(FILE* f, const HostMap& m) } } -const char* DNS_Mgr::LookupAddrInCache(const zeek::IPAddr& addr) +const char* DNS_Mgr::LookupAddrInCache(const IPAddr& addr) { AddrMap::iterator it = addr_mappings.find(addr); @@ -982,7 +982,7 @@ const char* DNS_Mgr::LookupAddrInCache(const zeek::IPAddr& addr) return d->names ? d->names[0] : "<\?\?\?>"; } -zeek::TableValPtr DNS_Mgr::LookupNameInCache(const string& name) +TableValPtr DNS_Mgr::LookupNameInCache(const string& name) { HostMap::iterator it = host_mappings.find(name); if ( it == host_mappings.end() ) @@ -1032,7 +1032,7 @@ const char* DNS_Mgr::LookupTextInCache(const string& name) } static void resolve_lookup_cb(DNS_Mgr::LookupCallback* callback, - zeek::TableValPtr result) + TableValPtr result) { callback->Resolved(result.get()); delete callback; @@ -1045,7 +1045,7 @@ static void resolve_lookup_cb(DNS_Mgr::LookupCallback* callback, delete callback; } -void DNS_Mgr::AsyncLookupAddr(const zeek::IPAddr& host, LookupCallback* callback) +void DNS_Mgr::AsyncLookupAddr(const IPAddr& host, LookupCallback* callback) { InitSource(); @@ -1167,7 +1167,7 @@ static bool DoRequest(nb_dns_info* nb_dns, DNS_Mgr_Request* dr) // dr stored in nb_dns cookie and deleted later when results available. return true; - zeek::reporter->Warning("can't issue DNS request"); + reporter->Warning("can't issue DNS request"); delete dr; return false; } @@ -1204,14 +1204,14 @@ void DNS_Mgr::IssueAsyncRequests() continue; } - req->time = zeek::util::current_time(); + req->time = util::current_time(); asyncs_timeouts.push(req); ++asyncs_pending; } } -void DNS_Mgr::CheckAsyncAddrRequest(const zeek::IPAddr& addr, bool timeout) +void DNS_Mgr::CheckAsyncAddrRequest(const IPAddr& addr, bool timeout) { // Note that this code is a mirror of that for CheckAsyncHostRequest. @@ -1338,7 +1338,7 @@ double DNS_Mgr::GetNextTimeout() if ( asyncs_timeouts.empty() ) return -1; - return zeek::run_state::network_time + DNS_TIMEOUT; + return run_state::network_time + DNS_TIMEOUT; } void DNS_Mgr::Process() @@ -1350,7 +1350,7 @@ void DNS_Mgr::Process() { AsyncRequest* req = asyncs_timeouts.top(); - if ( req->time + DNS_TIMEOUT > zeek::util::current_time() && ! zeek::run_state::terminating ) + if ( req->time + DNS_TIMEOUT > util::current_time() && ! run_state::terminating ) break; if ( ! req->processed ) @@ -1376,7 +1376,7 @@ void DNS_Mgr::Process() int status = nb_dns_activity(nb_dns, &r, err); if ( status < 0 ) - zeek::reporter->Warning("NB-DNS error in DNS_Mgr::Process (%s)", err); + reporter->Warning("NB-DNS error in DNS_Mgr::Process (%s)", err); else if ( status > 0 ) { @@ -1416,7 +1416,7 @@ int DNS_Mgr::AnswerAvailable(int timeout) int fd = nb_dns_fd(nb_dns); if ( fd < 0 ) { - zeek::reporter->Warning("nb_dns_fd() failed in DNS_Mgr::WaitForReplies"); + reporter->Warning("nb_dns_fd() failed in DNS_Mgr::WaitForReplies"); return -1; } @@ -1434,14 +1434,14 @@ int DNS_Mgr::AnswerAvailable(int timeout) if ( status < 0 ) { if ( errno != EINTR ) - zeek::reporter->Warning("problem with DNS select"); + reporter->Warning("problem with DNS select"); return -1; } if ( status > 1 ) { - zeek::reporter->Warning("strange return from DNS select"); + reporter->Warning("strange return from DNS select"); return -1; } @@ -1462,7 +1462,7 @@ void DNS_Mgr::GetStats(Stats* stats) void DNS_Mgr::Terminate() { if ( nb_dns ) - zeek::iosource_mgr->UnregisterFd(nb_dns_fd(nb_dns), this); + iosource_mgr->UnregisterFd(nb_dns_fd(nb_dns), this); } } // namespace zeek::detail diff --git a/src/DNS_Mgr.h b/src/DNS_Mgr.h index 90d2fa7359..a857b38603 100644 --- a/src/DNS_Mgr.h +++ b/src/DNS_Mgr.h @@ -22,9 +22,9 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(TableVal, zeek); namespace zeek { template class IntrusivePtr; -using ValPtr = zeek::IntrusivePtr; -using ListValPtr = zeek::IntrusivePtr; -using TableValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; +using ListValPtr = IntrusivePtr; +using TableValPtr = IntrusivePtr; } // Defined in nb_dns.h @@ -33,7 +33,7 @@ struct nb_dns_result; namespace zeek::detail { -using DNS_mgr_request_list = zeek::PList; +using DNS_mgr_request_list = PList; class DNS_Mapping; @@ -47,7 +47,7 @@ enum DNS_MgrMode { // Number of seconds we'll wait for a reply. #define DNS_TIMEOUT 5 -class DNS_Mgr final : public zeek::iosource::IOSource { +class DNS_Mgr final : public iosource::IOSource { public: explicit DNS_Mgr(DNS_MgrMode mode); ~DNS_Mgr() override; @@ -57,19 +57,19 @@ public: // Looks up the address or addresses of the given host, and returns // a set of addr. - zeek::TableValPtr LookupHost(const char* host); + TableValPtr LookupHost(const char* host); - zeek::ValPtr LookupAddr(const zeek::IPAddr& addr); + ValPtr LookupAddr(const IPAddr& addr); // Define the directory where to store the data. - void SetDir(const char* arg_dir) { dir = zeek::util::copy_string(arg_dir); } + void SetDir(const char* arg_dir) { dir = util::copy_string(arg_dir); } void Verify(); void Resolve(); bool Save(); - const char* LookupAddrInCache(const zeek::IPAddr& addr); - zeek::TableValPtr LookupNameInCache(const std::string& name); + const char* LookupAddrInCache(const IPAddr& addr); + TableValPtr LookupNameInCache(const std::string& name); const char* LookupTextInCache(const std::string& name); // Support for async lookups. @@ -79,11 +79,11 @@ public: virtual ~LookupCallback() { } virtual void Resolved(const char* name) { }; - virtual void Resolved(zeek::TableVal* addrs) { }; + virtual void Resolved(TableVal* addrs) { }; virtual void Timeout() = 0; }; - void AsyncLookupAddr(const zeek::IPAddr& host, LookupCallback* callback); + void AsyncLookupAddr(const IPAddr& host, LookupCallback* callback); void AsyncLookupName(const std::string& name, LookupCallback* callback); void AsyncLookupNameText(const std::string& name, LookupCallback* callback); @@ -105,20 +105,20 @@ protected: friend class LookupCallback; friend class DNS_Mgr_Request; - void Event(zeek::EventHandlerPtr e, DNS_Mapping* dm); - void Event(zeek::EventHandlerPtr e, DNS_Mapping* dm, - zeek::ListValPtr l1, zeek::ListValPtr l2); - void Event(zeek::EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm); + void Event(EventHandlerPtr e, DNS_Mapping* dm); + void Event(EventHandlerPtr e, DNS_Mapping* dm, + ListValPtr l1, ListValPtr l2); + void Event(EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm); - zeek::ValPtr BuildMappingVal(DNS_Mapping* dm); + ValPtr BuildMappingVal(DNS_Mapping* dm); void AddResult(DNS_Mgr_Request* dr, struct nb_dns_result* r); void CompareMappings(DNS_Mapping* prev_dm, DNS_Mapping* new_dm); - zeek::ListValPtr AddrListDelta(zeek::ListVal* al1, zeek::ListVal* al2); - void DumpAddrList(FILE* f, zeek::ListVal* al); + ListValPtr AddrListDelta(ListVal* al1, ListVal* al2); + void DumpAddrList(FILE* f, ListVal* al); typedef std::map > HostMap; - typedef std::map AddrMap; + typedef std::map AddrMap; typedef std::map TextMap; void LoadCache(FILE* f); void Save(FILE* f, const AddrMap& m); @@ -134,7 +134,7 @@ protected: // Finish the request if we have a result. If not, time it out if // requested. - void CheckAsyncAddrRequest(const zeek::IPAddr& addr, bool timeout); + void CheckAsyncAddrRequest(const IPAddr& addr, bool timeout); void CheckAsyncHostRequest(const char* host, bool timeout); void CheckAsyncTextRequest(const char* host, bool timeout); @@ -158,13 +158,13 @@ protected: bool did_init; - zeek::RecordTypePtr dm_rec; + RecordTypePtr dm_rec; typedef std::list CallbackList; struct AsyncRequest { double time; - zeek::IPAddr host; + IPAddr host; std::string name; CallbackList callbacks; bool is_txt; @@ -186,7 +186,7 @@ protected: processed = true; } - void Resolved(zeek::TableVal* addrs) + void Resolved(TableVal* addrs) { for ( CallbackList::iterator i = callbacks.begin(); i != callbacks.end(); ++i ) @@ -212,7 +212,7 @@ protected: }; - typedef std::map AsyncRequestAddrMap; + typedef std::map AsyncRequestAddrMap; AsyncRequestAddrMap asyncs_addrs; typedef std::map AsyncRequestNameMap; diff --git a/src/DbgBreakpoint.cc b/src/DbgBreakpoint.cc index e39d06e383..b76d1d6716 100644 --- a/src/DbgBreakpoint.cc +++ b/src/DbgBreakpoint.cc @@ -152,10 +152,10 @@ bool DbgBreakpoint::SetLocation(ParseLocationRec plr, std::string_view loc_str) { std::string loc_s(loc_str); kind = BP_FUNC; - function_name = make_full_var_name(zeek::detail::current_module.c_str(), + function_name = make_full_var_name(current_module.c_str(), loc_s.c_str()); at_stmt = plr.stmt; - const zeek::detail::Location* loc = at_stmt->GetLocationInfo(); + const Location* loc = at_stmt->GetLocationInfo(); snprintf(description, sizeof(description), "%s at %s:%d", function_name.c_str(), loc->filename, loc->last_line); @@ -167,7 +167,7 @@ bool DbgBreakpoint::SetLocation(ParseLocationRec plr, std::string_view loc_str) return true; } -bool DbgBreakpoint::SetLocation(zeek::detail::Stmt* stmt) +bool DbgBreakpoint::SetLocation(Stmt* stmt) { if ( ! stmt ) return false; @@ -178,7 +178,7 @@ bool DbgBreakpoint::SetLocation(zeek::detail::Stmt* stmt) SetEnable(true); AddToGlobalMap(); - const zeek::detail::Location* loc = stmt->GetLocationInfo(); + const Location* loc = stmt->GetLocationInfo(); snprintf(description, sizeof(description), "%s:%d", loc->filename, loc->last_line); @@ -219,7 +219,7 @@ bool DbgBreakpoint::Reset() break; } - zeek::reporter->InternalError("DbgBreakpoint::Reset function incomplete."); + reporter->InternalError("DbgBreakpoint::Reset function incomplete."); // Cannot be reached. return false; @@ -259,8 +259,8 @@ BreakCode DbgBreakpoint::HasHit() return BC_HIT; } - if ( ! zeek::IsIntegral(yes->GetType()->Tag()) && - ! zeek::IsBool(yes->GetType()->Tag()) ) + if ( ! IsIntegral(yes->GetType()->Tag()) && + ! IsBool(yes->GetType()->Tag()) ) { PrintHitMsg(); debug_msg("Breakpoint condition should return an integral type"); @@ -291,7 +291,7 @@ BreakCode DbgBreakpoint::HasHit() return BC_HIT; } -BreakCode DbgBreakpoint::ShouldBreak(zeek::detail::Stmt* s) +BreakCode DbgBreakpoint::ShouldBreak(Stmt* s) { if ( ! IsEnabled() ) return BC_NO_HIT; @@ -312,7 +312,7 @@ BreakCode DbgBreakpoint::ShouldBreak(zeek::detail::Stmt* s) assert(false); default: - zeek::reporter->InternalError("Invalid breakpoint type in DbgBreakpoint::ShouldBreak"); + reporter->InternalError("Invalid breakpoint type in DbgBreakpoint::ShouldBreak"); } // If we got here, that means that the breakpoint could hit, @@ -329,7 +329,7 @@ BreakCode DbgBreakpoint::ShouldBreak(zeek::detail::Stmt* s) BreakCode DbgBreakpoint::ShouldBreak(double t) { if ( kind != BP_TIME ) - zeek::reporter->InternalError("Calling ShouldBreak(time) on a non-time breakpoint"); + reporter->InternalError("Calling ShouldBreak(time) on a non-time breakpoint"); if ( t < at_time ) return BC_NO_HIT; @@ -352,13 +352,13 @@ void DbgBreakpoint::PrintHitMsg() case BP_LINE: { ODesc d; - zeek::detail::Frame* f = g_frame_stack.back(); - const zeek::detail::ScriptFunc* func = f->GetFunction(); + Frame* f = g_frame_stack.back(); + const ScriptFunc* func = f->GetFunction(); if ( func ) func->DescribeDebug (&d, f->GetFuncArgs()); - const zeek::detail::Location* loc = at_stmt->GetLocationInfo(); + const Location* loc = at_stmt->GetLocationInfo(); debug_msg("Breakpoint %d, %s at %s:%d\n", GetID(), d.Description(), @@ -370,7 +370,7 @@ void DbgBreakpoint::PrintHitMsg() assert(false); default: - zeek::reporter->InternalError("Missed a case in DbgBreakpoint::PrintHitMsg\n"); + reporter->InternalError("Missed a case in DbgBreakpoint::PrintHitMsg\n"); } } diff --git a/src/DbgBreakpoint.h b/src/DbgBreakpoint.h index 0c7e1ca1ec..22d4ae6dfb 100644 --- a/src/DbgBreakpoint.h +++ b/src/DbgBreakpoint.h @@ -23,7 +23,7 @@ public: // True if breakpoint could be set; false otherwise bool SetLocation(ParseLocationRec plr, std::string_view loc_str); - bool SetLocation(zeek::detail::Stmt* stmt); + bool SetLocation(Stmt* stmt); bool SetLocation(double time); bool Reset(); // cancel and re-apply bpt when restarting execution @@ -38,7 +38,7 @@ public: // // NOTE: If it returns a hit, the DbgBreakpoint object will take // appropriate action (e.g., resetting counters). - BreakCode ShouldBreak(zeek::detail::Stmt* s); + BreakCode ShouldBreak(Stmt* s); BreakCode ShouldBreak(double t); const std::string& GetCondition() const { return condition; } @@ -73,7 +73,7 @@ protected: bool enabled; // ### comment this and next bool temporary; - zeek::detail::Stmt* at_stmt; + Stmt* at_stmt; double at_time; // break when the virtual time is this // Support for conditional and N'th time breakpoints. diff --git a/src/DbgWatch.cc b/src/DbgWatch.cc index c1af0610fa..1ea5b71163 100644 --- a/src/DbgWatch.cc +++ b/src/DbgWatch.cc @@ -6,13 +6,17 @@ #include "DbgWatch.h" #include "Reporter.h" +namespace zeek::detail { + // Support classes -zeek::detail::DbgWatch::DbgWatch(zeek::Obj* var_to_watch) +DbgWatch::DbgWatch(zeek::Obj* var_to_watch) { - zeek::reporter->InternalError("DbgWatch unimplemented"); + reporter->InternalError("DbgWatch unimplemented"); } -zeek::detail::DbgWatch::DbgWatch(zeek::detail::Expr* expr_to_watch) +DbgWatch::DbgWatch(Expr* expr_to_watch) { - zeek::reporter->InternalError("DbgWatch unimplemented"); + reporter->InternalError("DbgWatch unimplemented"); } + +} // namespace zeek::detail diff --git a/src/DbgWatch.h b/src/DbgWatch.h index 192bd94e3b..d311978972 100644 --- a/src/DbgWatch.h +++ b/src/DbgWatch.h @@ -12,13 +12,13 @@ namespace zeek::detail { class DbgWatch { public: - explicit DbgWatch(zeek::Obj* var_to_watch); - explicit DbgWatch(zeek::detail::Expr* expr_to_watch); + explicit DbgWatch(Obj* var_to_watch); + explicit DbgWatch(Expr* expr_to_watch); ~DbgWatch() = default; protected: - zeek::Obj* var; - zeek::detail::Expr* expr; + Obj* var; + Expr* expr; }; } // namespace zeek::detail diff --git a/src/Debug.cc b/src/Debug.cc index 2a66e6e7bc..99a51ebf28 100644 --- a/src/Debug.cc +++ b/src/Debug.cc @@ -80,7 +80,7 @@ DebuggerState::DebuggerState() BreakFromSignal(false); // ### Don't choose this arbitrary size! Extend Frame. - dbg_locals = new zeek::detail::Frame(1024, /* func = */ nullptr, /* fn_args = */ nullptr); + dbg_locals = new Frame(1024, /* func = */ nullptr, /* fn_args = */ nullptr); } DebuggerState::~DebuggerState() @@ -91,7 +91,7 @@ DebuggerState::~DebuggerState() bool StmtLocMapping::StartsAfter(const StmtLocMapping* m2) { if ( ! m2 ) - zeek::reporter->InternalError("Assertion failed: m2 != 0"); + reporter->InternalError("Assertion failed: m2 != 0"); return loc.first_line > m2->loc.first_line || (loc.first_line == m2->loc.first_line && @@ -119,7 +119,7 @@ FILE* TraceState::SetTraceFile(const char* filename) { FILE* newfile; - if ( zeek::util::streq(filename, "-") ) + if ( util::streq(filename, "-") ) newfile = stderr; else newfile = fopen(filename, "w"); @@ -158,10 +158,10 @@ int TraceState::LogTrace(const char* fmt, ...) va_start(args, fmt); // Prefix includes timestamp and file/line info. - fprintf(trace_file, "%.6f ", zeek::run_state::network_time); + fprintf(trace_file, "%.6f ", run_state::network_time); - const zeek::detail::Stmt* stmt; - zeek::detail::Location loc; + const Stmt* stmt; + Location loc; loc.filename = nullptr; if ( g_frame_stack.size() > 0 && g_frame_stack.back() ) @@ -171,7 +171,7 @@ int TraceState::LogTrace(const char* fmt, ...) loc = *stmt->GetLocationInfo(); else { - const zeek::detail::ScriptFunc* f = g_frame_stack.back()->GetFunction(); + const ScriptFunc* f = g_frame_stack.back()->GetFunction(); if ( f ) loc = *f->GetLocationInfo(); } @@ -179,7 +179,7 @@ int TraceState::LogTrace(const char* fmt, ...) if ( ! loc.filename ) { - loc.filename = zeek::util::copy_string(""); + loc.filename = util::copy_string(""); loc.last_line = 0; } @@ -199,7 +199,7 @@ int TraceState::LogTrace(const char* fmt, ...) // Helper functions. -void get_first_statement(zeek::detail::Stmt* list, zeek::detail::Stmt*& first, zeek::detail::Location& loc) +void get_first_statement(Stmt* list, Stmt*& first, Location& loc) { if ( ! list ) { @@ -222,11 +222,11 @@ void get_first_statement(zeek::detail::Stmt* list, zeek::detail::Stmt*& first, z static void parse_function_name(vector& result, ParseLocationRec& plr, const string& s) { // function name - const auto& id = zeek::detail::lookup_ID(s.c_str(), zeek::detail::current_module.c_str()); + const auto& id = lookup_ID(s.c_str(), current_module.c_str()); if ( ! id ) { - string fullname = make_full_var_name(zeek::detail::current_module.c_str(), s.c_str()); + string fullname = make_full_var_name(current_module.c_str(), s.c_str()); debug_msg("Function %s not defined.\n", fullname.c_str()); plr.type = PLR_UNKNOWN; return; @@ -246,8 +246,8 @@ static void parse_function_name(vector& result, return; } - const zeek::Func* func = id->GetVal()->AsFunc(); - const vector& bodies = func->GetBodies(); + const Func* func = id->GetVal()->AsFunc(); + const vector& bodies = func->GetBodies(); if ( bodies.size() == 0 ) { @@ -256,7 +256,7 @@ static void parse_function_name(vector& result, return; } - zeek::detail::Stmt* body = nullptr; // the particular body we care about; 0 = all + Stmt* body = nullptr; // the particular body we care about; 0 = all if ( bodies.size() == 1 ) body = bodies[0].stmts.get(); @@ -268,8 +268,8 @@ static void parse_function_name(vector& result, "Please choose one of the following options:\n"); for ( unsigned int i = 0; i < bodies.size(); ++i ) { - zeek::detail::Stmt* first; - zeek::detail::Location stmt_loc; + Stmt* first; + Location stmt_loc; get_first_statement(bodies[i].stmts.get(), first, stmt_loc); debug_msg("[%d] %s:%d\n", i+1, stmt_loc.filename, stmt_loc.first_line); } @@ -311,8 +311,8 @@ static void parse_function_name(vector& result, plr.type = PLR_FUNCTION; // Find first atomic (non-STMT_LIST) statement - zeek::detail::Stmt* first; - zeek::detail::Location stmt_loc; + Stmt* first; + Location stmt_loc; if ( body ) { @@ -377,7 +377,7 @@ vector parse_location_string(const string& s) if ( ! sscanf(line_string.c_str(), "%d", &plr.line) ) plr.type = PLR_UNKNOWN; - string path(zeek::util::find_script_file(filename, zeek::util::zeek_path())); + string path(util::find_script_file(filename, util::zeek_path())); if ( path.empty() ) { @@ -395,7 +395,7 @@ vector parse_location_string(const string& s) { auto iter = g_dbgfilemaps.find(loc_filename); if ( iter == g_dbgfilemaps.end() ) - zeek::reporter->InternalError("Policy file %s should have been loaded\n", + reporter->InternalError("Policy file %s should have been loaded\n", loc_filename.data()); if ( plr.line > how_many_lines_in(loc_filename.data()) ) @@ -555,7 +555,7 @@ int dbg_execute_command(const char* cmd) if ( ! cmd ) return 0; - if ( zeek::util::streq(cmd, "") ) // do the GDB command completion + if ( util::streq(cmd, "") ) // do the GDB command completion { #ifdef HAVE_READLINE int i; @@ -581,7 +581,7 @@ int dbg_execute_command(const char* cmd) return 0; } - char* localcmd = zeek::util::copy_string(cmd); + char* localcmd = util::copy_string(cmd); string opstring; vector arguments; @@ -637,7 +637,7 @@ int dbg_execute_command(const char* cmd) #endif if ( int(cmd_code) >= num_debug_cmds() ) - zeek::reporter->InternalError("Assertion failed: int(cmd_code) < num_debug_cmds()"); + reporter->InternalError("Assertion failed: int(cmd_code) < num_debug_cmds()"); // Dispatch to the op-specific handler (with args). int retcode = dbg_dispatch_cmd(cmd_code, arguments); @@ -646,7 +646,7 @@ int dbg_execute_command(const char* cmd) const DebugCmdInfo* info = get_debug_cmd_info(cmd_code); if ( ! info ) - zeek::reporter->InternalError("Assertion failed: info"); + reporter->InternalError("Assertion failed: info"); if ( ! info ) return -2; // ### yuck, why -2? @@ -659,7 +659,7 @@ static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector& args) { switch ( cmd_code ) { case dcHelp: - zeek::detail::dbg_cmd_help(cmd_code, args); + dbg_cmd_help(cmd_code, args); break; case dcQuit: @@ -689,11 +689,11 @@ static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector& args) break; case dcBreak: - zeek::detail::dbg_cmd_break(cmd_code, args); + dbg_cmd_break(cmd_code, args); break; case dcBreakCondition: - zeek::detail::dbg_cmd_break_condition(cmd_code, args); + dbg_cmd_break_condition(cmd_code, args); break; case dcDeleteBreak: @@ -701,26 +701,26 @@ static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector& args) case dcDisableBreak: case dcEnableBreak: case dcIgnoreBreak: - zeek::detail::dbg_cmd_break_set_state(cmd_code, args); + dbg_cmd_break_set_state(cmd_code, args); break; case dcPrint: - zeek::detail::dbg_cmd_print(cmd_code, args); + dbg_cmd_print(cmd_code, args); break; case dcBacktrace: - return zeek::detail::dbg_cmd_backtrace(cmd_code, args); + return dbg_cmd_backtrace(cmd_code, args); case dcFrame: case dcUp: case dcDown: - return zeek::detail::dbg_cmd_frame(cmd_code, args); + return dbg_cmd_frame(cmd_code, args); case dcInfo: - return zeek::detail::dbg_cmd_info(cmd_code, args); + return dbg_cmd_info(cmd_code, args); case dcList: - return zeek::detail::dbg_cmd_list(cmd_code, args); + return dbg_cmd_list(cmd_code, args); case dcDisplay: case dcUndisplay: @@ -728,7 +728,7 @@ static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector& args) break; case dcTrace: - return zeek::detail::dbg_cmd_trace(cmd_code, args); + return dbg_cmd_trace(cmd_code, args); default: debug_msg("INTERNAL ERROR: " @@ -753,22 +753,22 @@ static char* get_prompt(bool reset_counter = false) return prompt; } -string get_context_description(const zeek::detail::Stmt* stmt, const zeek::detail::Frame* frame) +string get_context_description(const Stmt* stmt, const Frame* frame) { ODesc d; - const zeek::detail::ScriptFunc* func = frame ? frame->GetFunction() : nullptr; + const ScriptFunc* func = frame ? frame->GetFunction() : nullptr; if ( func ) func->DescribeDebug(&d, frame->GetFuncArgs()); else d.Add("", 0); - zeek::detail::Location loc; + Location loc; if ( stmt ) loc = *stmt->GetLocationInfo(); else { - loc.filename = zeek::util::copy_string(""); + loc.filename = util::copy_string(""); loc.last_line = 0; } @@ -794,18 +794,18 @@ int dbg_handle_debug_input() g_debugger_state.BreakFromSignal(false); } - zeek::detail::Frame* curr_frame = g_frame_stack.back(); - const zeek::detail::ScriptFunc* func = curr_frame->GetFunction(); + Frame* curr_frame = g_frame_stack.back(); + const ScriptFunc* func = curr_frame->GetFunction(); if ( func ) - zeek::detail::current_module = extract_module_name(func->Name()); + current_module = extract_module_name(func->Name()); else - zeek::detail::current_module = GLOBAL_MODULE_NAME; + current_module = GLOBAL_MODULE_NAME; - const zeek::detail::Stmt* stmt = curr_frame->GetNextStmt(); + const Stmt* stmt = curr_frame->GetNextStmt(); if ( ! stmt ) - zeek::reporter->InternalError("Assertion failed: stmt != 0"); + reporter->InternalError("Assertion failed: stmt != 0"); - const zeek::detail::Location loc = *stmt->GetLocationInfo(); + const Location loc = *stmt->GetLocationInfo(); if ( ! step_or_next_pending || g_frame_stack.back() != last_frame ) { @@ -831,7 +831,7 @@ int dbg_handle_debug_input() // readline uses malloc, and we want to be consistent // with it. - input_line = (char*) zeek::util::safe_malloc(1024); + input_line = (char*) util::safe_malloc(1024); input_line[1023] = 0; // ### Maybe it's not always stdin. input_line = fgets(input_line, 1023, stdin); @@ -865,7 +865,7 @@ int dbg_handle_debug_input() // Return true to continue execution, false to abort. -bool pre_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f) +bool pre_execute_stmt(Stmt* stmt, Frame* f) { if ( ! g_policy_debug || stmt->Tag() == STMT_LIST || stmt->Tag() == STMT_NULL ) @@ -909,7 +909,7 @@ bool pre_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f) p = g_debugger_state.breakpoint_map.equal_range(stmt); if ( p.first == p.second ) - zeek::reporter->InternalError("Breakpoint count nonzero, but no matching breakpoints"); + reporter->InternalError("Breakpoint count nonzero, but no matching breakpoints"); for ( BPMapType::iterator i = p.first; i != p.second; ++i ) { @@ -930,7 +930,7 @@ bool pre_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f) return true; } -bool post_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f, zeek::Val* result, zeek::detail::StmtFlowType* flow) +bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, StmtFlowType* flow) { // Handle the case where someone issues a "next" debugger command, // but we're at a return statement, so the next statement is in @@ -957,7 +957,7 @@ bool post_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f, zeek::V return true; } -zeek::ValPtr dbg_eval_expr(const char* expr) +ValPtr dbg_eval_expr(const char* expr) { // Push the current frame's associated scope. // Note: g_debugger_state.curr_frame_idx is the user-visible number, @@ -966,17 +966,17 @@ zeek::ValPtr dbg_eval_expr(const char* expr) (g_frame_stack.size() - 1) - g_debugger_state.curr_frame_idx; if ( ! (frame_idx >= 0 && (unsigned) frame_idx < g_frame_stack.size()) ) - zeek::reporter->InternalError("Assertion failed: frame_idx >= 0 && (unsigned) frame_idx < g_frame_stack.size()"); + reporter->InternalError("Assertion failed: frame_idx >= 0 && (unsigned) frame_idx < g_frame_stack.size()"); - zeek::detail::Frame* frame = g_frame_stack[frame_idx]; + Frame* frame = g_frame_stack[frame_idx]; if ( ! (frame) ) - zeek::reporter->InternalError("Assertion failed: frame"); + reporter->InternalError("Assertion failed: frame"); - const zeek::detail::ScriptFunc* func = frame->GetFunction(); + const ScriptFunc* func = frame->GetFunction(); if ( func ) { Ref(func->GetScope()); - zeek::detail::push_existing_scope(func->GetScope()); + push_existing_scope(func->GetScope()); } // ### Possibly push a debugger-local scope? @@ -992,7 +992,7 @@ zeek::ValPtr dbg_eval_expr(const char* expr) yylloc.first_line = yylloc.last_line = line_number = 1; // Parse the thing into an expr. - zeek::ValPtr result; + ValPtr result; if ( yyparse() ) { if ( g_curr_debug_error ) @@ -1010,7 +1010,7 @@ zeek::ValPtr dbg_eval_expr(const char* expr) result = g_curr_debug_expr->Eval(frame); if ( func ) - zeek::detail::pop_scope(); + pop_scope(); delete g_curr_debug_expr; g_curr_debug_expr = nullptr; diff --git a/src/Debug.h b/src/Debug.h index 92efac4615..e2201aab2a 100644 --- a/src/Debug.h +++ b/src/Debug.h @@ -32,15 +32,15 @@ class ParseLocationRec { public: ParseLocationRecType type; int32_t line; - zeek::detail::Stmt* stmt; + Stmt* stmt; const char* filename; }; class StmtLocMapping; -using Filemap = zeek::PQueue; // mapping for a single file +using Filemap = PQueue; // mapping for a single file -using BPIDMapType = std::map; -using BPMapType = std::multimap; +using BPIDMapType = std::map; +using BPMapType = std::multimap; class TraceState { public: @@ -87,11 +87,11 @@ public: bool already_did_list; // did we already do a 'list' command? - zeek::detail::Location last_loc; // used by 'list'; the last location listed + Location last_loc; // used by 'list'; the last location listed BPIDMapType breakpoints; // BPID -> Breakpoint - std::vector watches; - std::vector displays; + std::vector watches; + std::vector displays; BPMapType breakpoint_map; // maps Stmt -> Breakpoints on it protected: @@ -101,7 +101,7 @@ protected: int next_bp_id, next_watch_id, next_display_id; private: - zeek::detail::Frame* dbg_locals; // unused + Frame* dbg_locals; // unused }; // Source line -> statement mapping. @@ -109,15 +109,15 @@ private: class StmtLocMapping { public: StmtLocMapping() { } - StmtLocMapping(const zeek::detail::Location* l, zeek::detail::Stmt* s) { loc = *l; stmt = s; } + StmtLocMapping(const Location* l, Stmt* s) { loc = *l; stmt = s; } bool StartsAfter(const StmtLocMapping* m2); - const zeek::detail::Location& Loc() const { return loc; } - zeek::detail::Stmt* Statement() const { return stmt; } + const Location& Loc() const { return loc; } + Stmt* Statement() const { return stmt; } protected: - zeek::detail::Location loc; - zeek::detail::Stmt* stmt; + Location loc; + Stmt* stmt; }; extern bool g_policy_debug; // enable debugging facility @@ -147,8 +147,8 @@ std::vector parse_location_string(const std::string& s); // Debugging hooks. // Return true to continue execution, false to abort. -bool pre_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f); -bool post_execute_stmt(zeek::detail::Stmt* stmt, zeek::detail::Frame* f, zeek::Val* result, StmtFlowType* flow); +bool pre_execute_stmt(Stmt* stmt, Frame* f); +bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, StmtFlowType* flow); // Returns 1 if successful, 0 otherwise. // If cmdfile is non-nil, it contains the location of a file of commands @@ -164,19 +164,19 @@ int dbg_handle_debug_input(); // read a line and then have it executed int dbg_execute_command(const char* cmd); // Interactive expression evaluation. -zeek::ValPtr dbg_eval_expr(const char* expr); +ValPtr dbg_eval_expr(const char* expr); // Get line that looks like "In FnFoo(arg = val) at File:Line". -std::string get_context_description(const zeek::detail::Stmt* stmt, const zeek::detail::Frame* frame); +std::string get_context_description(const Stmt* stmt, const Frame* frame); -extern zeek::detail::Frame* g_dbg_locals; // variables created within debugger context +extern Frame* g_dbg_locals; // variables created within debugger context extern std::map g_dbgfilemaps; // filename => filemap // Perhaps add a code/priority argument to do selective output. int debug_msg(const char* fmt, ...) __attribute__ ((format (printf, 1, 2))); -} // namespace zeek::detail +} // namespace detail } // namespace zeek constexpr auto plrUnknown [[deprecated("Remove in v4.1. Use zeek::detail::PLR_UNKNOWN.")]] = zeek::detail::PLR_UNKNOWN; diff --git a/src/DebugCmdInfoConstants.cc b/src/DebugCmdInfoConstants.cc index 9126887220..154601db84 100644 --- a/src/DebugCmdInfoConstants.cc +++ b/src/DebugCmdInfoConstants.cc @@ -5,278 +5,282 @@ // #include "util.h" -void zeek::detail::init_global_dbg_constants () { +namespace zeek::detail { + +void init_global_dbg_constants () { { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { }; - info = new zeek::detail::DebugCmdInfo(dcInvalid, names, 0, false, "This function should not be called", + info = new DebugCmdInfo(dcInvalid, names, 0, false, "This function should not be called", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "help" }; - info = new zeek::detail::DebugCmdInfo(dcHelp, names, 1, false, "Get help with debugger commands", + info = new DebugCmdInfo(dcHelp, names, 1, false, "Get help with debugger commands", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "quit" }; - info = new zeek::detail::DebugCmdInfo(dcQuit, names, 1, false, "Exit Zeek", + info = new DebugCmdInfo(dcQuit, names, 1, false, "Exit Zeek", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "next" }; - info = new zeek::detail::DebugCmdInfo(dcNext, names, 1, true, "Step to the following statement, skipping function calls", + info = new DebugCmdInfo(dcNext, names, 1, true, "Step to the following statement, skipping function calls", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "step", "s" }; - info = new zeek::detail::DebugCmdInfo(dcStep, names, 2, true, "Step to following statements, stepping in to function calls", + info = new DebugCmdInfo(dcStep, names, 2, true, "Step to following statements, stepping in to function calls", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "continue", "c" }; - info = new zeek::detail::DebugCmdInfo(dcContinue, names, 2, true, "Resume execution of the policy script", + info = new DebugCmdInfo(dcContinue, names, 2, true, "Resume execution of the policy script", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "finish" }; - info = new zeek::detail::DebugCmdInfo(dcFinish, names, 1, true, "Run until the currently-executing function completes", + info = new DebugCmdInfo(dcFinish, names, 1, true, "Run until the currently-executing function completes", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "break", "b" }; - info = new zeek::detail::DebugCmdInfo(dcBreak, names, 2, false, "Set a breakpoint", + info = new DebugCmdInfo(dcBreak, names, 2, false, "Set a breakpoint", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "cond" }; - info = new zeek::detail::DebugCmdInfo(dcBreakCondition, names, 1, false, "", + info = new DebugCmdInfo(dcBreakCondition, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "delete", "d" }; - info = new zeek::detail::DebugCmdInfo(dcDeleteBreak, names, 2, false, "Delete the specified breakpoints; delete all if no arguments", + info = new DebugCmdInfo(dcDeleteBreak, names, 2, false, "Delete the specified breakpoints; delete all if no arguments", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "clear" }; - info = new zeek::detail::DebugCmdInfo(dcClearBreak, names, 1, false, "", + info = new DebugCmdInfo(dcClearBreak, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "disable", "dis" }; - info = new zeek::detail::DebugCmdInfo(dcDisableBreak, names, 2, false, "", + info = new DebugCmdInfo(dcDisableBreak, names, 2, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "enable" }; - info = new zeek::detail::DebugCmdInfo(dcEnableBreak, names, 1, false, "", + info = new DebugCmdInfo(dcEnableBreak, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "ignore" }; - info = new zeek::detail::DebugCmdInfo(dcIgnoreBreak, names, 1, false, "", + info = new DebugCmdInfo(dcIgnoreBreak, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "print", "p", "set" }; - info = new zeek::detail::DebugCmdInfo(dcPrint, names, 3, false, "Evaluate an expression and print the result (also aliased as 'set')", + info = new DebugCmdInfo(dcPrint, names, 3, false, "Evaluate an expression and print the result (also aliased as 'set')", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "backtrace", "bt", "where" }; - info = new zeek::detail::DebugCmdInfo(dcBacktrace, names, 3, false, "Print a stack trace (with +- N argument, inner/outer N frames only)", + info = new DebugCmdInfo(dcBacktrace, names, 3, false, "Print a stack trace (with +- N argument, inner/outer N frames only)", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "frame" }; - info = new zeek::detail::DebugCmdInfo(dcFrame, names, 1, false, "Select frame number N", + info = new DebugCmdInfo(dcFrame, names, 1, false, "Select frame number N", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "up" }; - info = new zeek::detail::DebugCmdInfo(dcUp, names, 1, false, "Select the stack frame one level up", + info = new DebugCmdInfo(dcUp, names, 1, false, "Select the stack frame one level up", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "down" }; - info = new zeek::detail::DebugCmdInfo(dcDown, names, 1, false, "Select the stack frame one level down", + info = new DebugCmdInfo(dcDown, names, 1, false, "Select the stack frame one level down", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "info" }; - info = new zeek::detail::DebugCmdInfo(dcInfo, names, 1, false, "Get information about the debugging environment", + info = new DebugCmdInfo(dcInfo, names, 1, false, "Get information about the debugging environment", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "list", "l" }; - info = new zeek::detail::DebugCmdInfo(dcList, names, 2, false, "Print source lines surrounding specified context", + info = new DebugCmdInfo(dcList, names, 2, false, "Print source lines surrounding specified context", true); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "display" }; - info = new zeek::detail::DebugCmdInfo(dcDisplay, names, 1, false, "", + info = new DebugCmdInfo(dcDisplay, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "undisplay" }; - info = new zeek::detail::DebugCmdInfo(dcUndisplay, names, 1, false, "", + info = new DebugCmdInfo(dcUndisplay, names, 1, false, "", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } { - zeek::detail::DebugCmdInfo* info; + DebugCmdInfo* info; const char * const names[] = { "trace" }; - info = new zeek::detail::DebugCmdInfo(dcTrace, names, 1, false, "Turn on or off execution tracing (with no arguments, prints current state.)", + info = new DebugCmdInfo(dcTrace, names, 1, false, "Turn on or off execution tracing (with no arguments, prints current state.)", false); - zeek::detail::g_DebugCmdInfos.push_back(info); + g_DebugCmdInfos.push_back(info); } } + +} // namespace zeek::detail diff --git a/src/DebugCmds.cc b/src/DebugCmds.cc index 431098765d..011fc86063 100644 --- a/src/DebugCmds.cc +++ b/src/DebugCmds.cc @@ -26,6 +26,11 @@ using namespace std; +zeek::PQueue zeek::detail::g_DebugCmdInfos; +zeek::PQueue& g_DebugCmdInfos = zeek::detail::g_DebugCmdInfos; + +namespace zeek::detail { + // // Helper routines // @@ -34,10 +39,10 @@ static bool string_is_regex(const string& s) return strpbrk(s.data(), "?*\\+"); } -static void lookup_global_symbols_regex(const string& orig_regex, vector& matches, +static void lookup_global_symbols_regex(const string& orig_regex, vector& matches, bool func_only = false) { - if ( zeek::util::streq(orig_regex.c_str(), "") ) + if ( util::streq(orig_regex.c_str(), "") ) return; string regex = "^"; @@ -53,24 +58,24 @@ static void lookup_global_symbols_regex(const string& orig_regex, vectorVars(); - zeek::detail::ID* nextid; + ID* nextid; for ( const auto& sym : syms ) { - zeek::detail::ID* nextid = sym.second.get(); - if ( ! func_only || nextid->GetType()->Tag() == zeek::TYPE_FUNC ) + ID* nextid = sym.second.get(); + if ( ! func_only || nextid->GetType()->Tag() == TYPE_FUNC ) if ( ! regexec (&re, nextid->Name(), 0, 0, 0) ) matches.push_back(nextid); } } -static void choose_global_symbols_regex(const string& regex, vector& choices, +static void choose_global_symbols_regex(const string& regex, vector& choices, bool func_only = false) { lookup_global_symbols_regex(regex, choices, func_only); @@ -80,14 +85,14 @@ static void choose_global_symbols_regex(const string& regex, vectorName()); + debug_msg("[%zu] %s\n", i+1, choices[i]->Name()); - zeek::detail::debug_msg("[a] All of the above\n"); - zeek::detail::debug_msg("[n] None of the above\n"); - zeek::detail::debug_msg("Enter your choice: "); + debug_msg("[a] All of the above\n"); + debug_msg("[n] None of the above\n"); + debug_msg("Enter your choice: "); char charinput[256]; if ( ! fgets(charinput, sizeof(charinput) - 1, stdin) ) @@ -110,7 +115,7 @@ static void choose_global_symbols_regex(const string& regex, vector 0 && option <= (int) choices.size() ) { - zeek::detail::ID* choice = choices[option - 1]; + ID* choice = choices[option - 1]; choices.clear(); choices.push_back(choice); return; @@ -123,11 +128,6 @@ static void choose_global_symbols_regex(const string& regex, vector zeek::detail::g_DebugCmdInfos; -zeek::PQueue& g_DebugCmdInfos = zeek::detail::g_DebugCmdInfos; - -namespace zeek::detail { - DebugCmdInfo::DebugCmdInfo(const DebugCmdInfo& info) : cmd(info.cmd), helpstring(nullptr) { @@ -206,7 +206,7 @@ static int dbg_backtrace_internal(int start, int end) if ( start < 0 || end < 0 || (unsigned) start >= g_frame_stack.size() || (unsigned) end >= g_frame_stack.size() ) - zeek::reporter->InternalError("Invalid stack frame index in DbgBacktraceInternal\n"); + reporter->InternalError("Invalid stack frame index in DbgBacktraceInternal\n"); if ( start < end ) { @@ -217,8 +217,8 @@ static int dbg_backtrace_internal(int start, int end) for ( int i = start; i >= end; --i ) { - const zeek::detail::Frame* f = g_frame_stack[i]; - const zeek::detail::Stmt* stmt = f ? f->GetNextStmt() : nullptr; + const Frame* f = g_frame_stack[i]; + const Stmt* stmt = f ? f->GetNextStmt() : nullptr; string context = get_context_description(stmt, f); debug_msg("#%d %s\n", @@ -335,11 +335,11 @@ int dbg_cmd_frame(DebugCmd cmd, const vector& args) // Set the current location to the new frame being looked at // for 'list', 'break', etc. - const zeek::detail::Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt(); + const Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt(); if ( ! stmt ) - zeek::reporter->InternalError("Assertion failed: %s", "stmt != 0"); + reporter->InternalError("Assertion failed: %s", "stmt != 0"); - const zeek::detail::Location loc = *stmt->GetLocationInfo(); + const Location loc = *stmt->GetLocationInfo(); g_debugger_state.last_loc = loc; g_debugger_state.already_did_list = false; @@ -375,9 +375,9 @@ int dbg_cmd_break(DebugCmd cmd, const vector& args) g_frame_stack.size() - 1 - g_debugger_state.curr_frame_idx; - zeek::detail::Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt(); + Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt(); if ( ! stmt ) - zeek::reporter->InternalError("Assertion failed: %s", "stmt != 0"); + reporter->InternalError("Assertion failed: %s", "stmt != 0"); DbgBreakpoint* bp = new DbgBreakpoint(); bp->SetID(g_debugger_state.NextBPID()); @@ -400,7 +400,7 @@ int dbg_cmd_break(DebugCmd cmd, const vector& args) vector locstrings; if ( string_is_regex(args[0]) ) { - vector choices; + vector choices; choose_global_symbols_regex(args[0], choices, true); for ( unsigned int i = 0; i < choices.size(); ++i ) locstrings.push_back(choices[i]->Name()); @@ -540,7 +540,7 @@ int dbg_cmd_break_set_state(DebugCmd cmd, const vector& args) break; default: - zeek::reporter->InternalError("Invalid command in DbgCmdBreakSetState\n"); + reporter->InternalError("Invalid command in DbgCmdBreakSetState\n"); } } diff --git a/src/DebugCmds.h b/src/DebugCmds.h index ddcb305c11..44b9d4574d 100644 --- a/src/DebugCmds.h +++ b/src/DebugCmds.h @@ -43,7 +43,7 @@ protected: bool repeatable; }; -extern zeek::PQueue g_DebugCmdInfos; +extern PQueue g_DebugCmdInfos; void init_global_dbg_constants (); diff --git a/src/DebugLogger.cc b/src/DebugLogger.cc index 09a2869017..5a4a468847 100644 --- a/src/DebugLogger.cc +++ b/src/DebugLogger.cc @@ -49,14 +49,14 @@ void DebugLogger::OpenDebugLog(const char* filename) { if ( filename ) { - filename = zeek::util::detail::log_file_name(filename); + filename = util::detail::log_file_name(filename); file = fopen(filename, "w"); if ( ! file ) { // The reporter may not be initialized here yet. - if ( zeek::reporter ) - zeek::reporter->FatalError("can't open '%s' for debugging output", filename); + if ( reporter ) + reporter->FatalError("can't open '%s' for debugging output", filename); else { fprintf(stderr, "can't open '%s' for debugging output\n", filename); @@ -93,7 +93,7 @@ void DebugLogger::ShowStreamsHelp() void DebugLogger::EnableStreams(const char* s) { char* brkt; - char* tmp = zeek::util::copy_string(s); + char* tmp = util::copy_string(s); char* tok = strtok(tmp, ","); while ( tok ) @@ -142,7 +142,7 @@ void DebugLogger::EnableStreams(const char* s) } } - zeek::reporter->FatalError("unknown debug stream '%s', try -B help.\n", tok); + reporter->FatalError("unknown debug stream '%s', try -B help.\n", tok); next: tok = strtok(0, ","); @@ -159,7 +159,7 @@ void DebugLogger::Log(DebugStream stream, const char* fmt, ...) return; fprintf(file, "%17.06f/%17.06f [%s] ", - zeek::run_state::network_time, zeek::util::current_time(true), g->prefix); + run_state::network_time, util::current_time(true), g->prefix); for ( int i = g->indent; i > 0; --i ) fputs(" ", file); @@ -173,16 +173,16 @@ void DebugLogger::Log(DebugStream stream, const char* fmt, ...) fflush(file); } -void DebugLogger::Log(const zeek::plugin::Plugin& plugin, const char* fmt, ...) +void DebugLogger::Log(const plugin::Plugin& plugin, const char* fmt, ...) { std::string tok = std::string("plugin-") + plugin.Name(); - tok = zeek::util::strreplace(tok, "::", "-"); + tok = util::strreplace(tok, "::", "-"); if ( enabled_streams.find(tok) == enabled_streams.end() ) return; fprintf(file, "%17.06f/%17.06f [plugin %s] ", - zeek::run_state::network_time, zeek::util::current_time(true), plugin.Name().c_str()); + run_state::network_time, util::current_time(true), plugin.Name().c_str()); va_list ap; va_start(ap, fmt); diff --git a/src/DebugLogger.h b/src/DebugLogger.h index 9929011278..54257e1a6f 100644 --- a/src/DebugLogger.h +++ b/src/DebugLogger.h @@ -62,7 +62,7 @@ public: void OpenDebugLog(const char* filename = 0); void Log(DebugStream stream, const char* fmt, ...) __attribute__((format(printf, 3, 4))); - void Log(const zeek::plugin::Plugin& plugin, const char* fmt, ...) __attribute__((format(printf, 3, 4))); + void Log(const plugin::Plugin& plugin, const char* fmt, ...) __attribute__((format(printf, 3, 4))); void PushIndent(DebugStream stream) { ++streams[int(stream)].indent; } diff --git a/src/Desc.cc b/src/Desc.cc index 3632476c7c..3a76bbc60c 100644 --- a/src/Desc.cc +++ b/src/Desc.cc @@ -18,7 +18,7 @@ namespace zeek { -ODesc::ODesc(desc_type t, zeek::File* arg_f) +ODesc::ODesc(DescType t, File* arg_f) { type = t; style = STANDARD_STYLE; @@ -27,7 +27,7 @@ ODesc::ODesc(desc_type t, zeek::File* arg_f) if ( f == nullptr ) { size = DEFAULT_SIZE; - base = zeek::util::safe_malloc(size); + base = util::safe_malloc(size); ((char*) base)[0] = '\0'; offset = 0; } @@ -77,7 +77,7 @@ void ODesc::PushIndent() void ODesc::PopIndent() { if ( --indent_level < 0 ) - zeek::reporter->InternalError("ODesc::PopIndent underflow"); + reporter->InternalError("ODesc::PopIndent underflow"); NL(); } @@ -85,7 +85,7 @@ void ODesc::PopIndent() void ODesc::PopIndentNoNL() { if ( --indent_level < 0 ) - zeek::reporter->InternalError("ODesc::PopIndent underflow"); + reporter->InternalError("ODesc::PopIndent underflow"); } void ODesc::Add(const char* s, int do_indent) @@ -180,12 +180,12 @@ void ODesc::Add(double d, bool no_exp) } } -void ODesc::Add(const zeek::IPAddr& addr) +void ODesc::Add(const IPAddr& addr) { Add(addr.AsString()); } -void ODesc::Add(const zeek::IPPrefix& prefix) +void ODesc::Add(const IPPrefix& prefix) { Add(prefix.AsString()); } @@ -199,7 +199,7 @@ void ODesc::AddCS(const char* s) Add(s); } -void ODesc::AddBytes(const zeek::String* s) +void ODesc::AddBytes(const String* s) { if ( IsReadable() ) { @@ -207,7 +207,7 @@ void ODesc::AddBytes(const zeek::String* s) AddBytes(reinterpret_cast(s->Bytes()), s->Len()); else { - const char* str = s->Render(zeek::String::EXPANDED_STRING); + const char* str = s->Render(String::EXPANDED_STRING); Add(str); delete [] str; } @@ -335,7 +335,7 @@ void ODesc::AddBytes(const void* bytes, unsigned int n) if ( p.first ) { AddBytesRaw(s, p.first - s); - zeek::util::get_escaped_string(this, p.first, p.second, true); + util::get_escaped_string(this, p.first, p.second, true); s = p.first + p.second; } else @@ -360,7 +360,7 @@ void ODesc::AddBytesRaw(const void* bytes, unsigned int n) if ( ! write_failed ) // Most likely it's a "disk full" so report // subsequent failures only once. - zeek::reporter->Error("error writing to %s: %s", f->Name(), strerror(errno)); + reporter->Error("error writing to %s: %s", f->Name(), strerror(errno)); write_failed = true; return; @@ -388,7 +388,7 @@ void ODesc::Grow(unsigned int n) while ( offset + n + SLOP >= size ) size *= 2; - base = zeek::util::safe_realloc(base, size); + base = util::safe_realloc(base, size); } void ODesc::Clear() @@ -400,24 +400,24 @@ void ODesc::Clear() { free(base); size = DEFAULT_SIZE; - base = zeek::util::safe_malloc(size); + base = util::safe_malloc(size); ((char*) base)[0] = '\0'; } } -bool ODesc::PushType(const zeek::Type* type) +bool ODesc::PushType(const Type* type) { auto res = encountered_types.insert(type); return std::get<1>(res); } -bool ODesc::PopType(const zeek::Type* type) +bool ODesc::PopType(const Type* type) { size_t res = encountered_types.erase(type); return (res == 1); } -bool ODesc::FindType(const zeek::Type* type) +bool ODesc::FindType(const Type* type) { auto res = encountered_types.find(type); diff --git a/src/Desc.h b/src/Desc.h index 7a33a02ba6..634498f0c2 100644 --- a/src/Desc.h +++ b/src/Desc.h @@ -11,31 +11,28 @@ #include // for u_char -namespace zeek { class File; } -using BroFile [[deprecated("Remove in v4.1. Use zeek::File.")]] = zeek::File; - ZEEK_FORWARD_DECLARE_NAMESPACED(IPAddr, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(IPPrefix, zeek); -namespace zeek { class Type; } -using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type; - namespace zeek { -enum desc_type { +class File; +class Type; + +enum DescType { DESC_READABLE, DESC_PORTABLE, DESC_BINARY, }; -enum desc_style { +enum DescStyle { STANDARD_STYLE, RAW_STYLE, }; class ODesc { public: - explicit ODesc(desc_type t=DESC_READABLE, zeek::File* f=nullptr); + explicit ODesc(DescType t=DESC_READABLE, File* f=nullptr); ~ODesc(); @@ -56,8 +53,8 @@ public: bool IncludeStats() const { return include_stats; } void SetIncludeStats(bool s) { include_stats = s; } - desc_style Style() const { return style; } - void SetStyle(desc_style s) { style = s; } + DescStyle Style() const { return style; } + void SetStyle(DescStyle s) { style = s; } void SetFlush(bool arg_do_flush) { do_flush = arg_do_flush; } @@ -91,13 +88,13 @@ public: void Add(int64_t i); void Add(uint64_t u); void Add(double d, bool no_exp=false); - void Add(const zeek::IPAddr& addr); - void Add(const zeek::IPPrefix& prefix); + void Add(const IPAddr& addr); + void Add(const IPPrefix& prefix); // Add s as a counted string. void AddCS(const char* s); - void AddBytes(const zeek::String* s); + void AddBytes(const String* s); void Add(const char* s1, const char* s2) { Add(s1); Add(s2); } @@ -134,7 +131,7 @@ public: const char* Description() const { return (const char*) base; } const u_char* Bytes() const { return (const u_char *) base; } - zeek::byte_vec TakeBytes() + byte_vec TakeBytes() { const void* t = base; base = nullptr; @@ -143,7 +140,7 @@ public: // Don't clear offset, as we want to still support // subsequent calls to Len(). - return zeek::byte_vec(t); + return byte_vec(t); } int Len() const { return offset; } @@ -152,9 +149,9 @@ public: // Used to determine recursive types. Records push their types on here; // if the same type (by address) is re-encountered, processing aborts. - bool PushType(const zeek::Type* type); - bool PopType(const zeek::Type* type); - bool FindType(const zeek::Type* type); + bool PushType(const Type* type); + bool PopType(const Type* type); + bool FindType(const Type* type); protected: void Indent(); @@ -187,8 +184,8 @@ protected: */ size_t StartsWithEscapeSequence(const char* start, const char* end); - desc_type type; - desc_style style; + DescType type; + DescStyle style; void* base; // beginning of buffer unsigned int offset; // where we are in the buffer @@ -204,23 +201,26 @@ protected: using escape_set = std::set; escape_set escape_sequences; // additional sequences of chars to escape - zeek::File* f; // or the file we're using. + File* f; // or the file we're using. int indent_level; bool do_flush; bool include_stats; - std::set encountered_types; + std::set encountered_types; }; } // namespace zeek +using BroFile [[deprecated("Remove in v4.1. Use zeek::File.")]] = zeek::File; +using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type; + using ODesc [[deprecated("Remove in v4.1. Use zeek::ODesc.")]] = zeek::ODesc; -using desc_type [[deprecated("Remove in v4.1. Use zeek::desc_type.")]] = zeek::desc_type; +using desc_type [[deprecated("Remove in v4.1. Use zeek::DescType.")]] = zeek::DescType; constexpr auto DESC_READABLE [[deprecated("Remove in v4.1. Use zeek::DESC_READABLE.")]] = zeek::DESC_READABLE; constexpr auto DESC_PORTABLE [[deprecated("Remove in v4.1. Use zeek::DESC_PORTABLE.")]] = zeek::DESC_PORTABLE; constexpr auto DESC_BINARY [[deprecated("Remove in v4.1. Use zeek::DESC_BINARY.")]] = zeek::DESC_BINARY; -using desc_style [[deprecated("Remove in v4.1. Use zeek::desc_style.")]] = zeek::desc_style; +using desc_style [[deprecated("Remove in v4.1. Use zeek::DescStyle.")]] = zeek::DescStyle; constexpr auto STANDARD_STYLE [[deprecated("Remove in v4.1. Use zeek::STANDARD_STYLE.")]] = zeek::STANDARD_STYLE; constexpr auto RAW_STYLE [[deprecated("Remove in v4.1. Use zeek::RAW_STYLE.")]] = zeek::RAW_STYLE; diff --git a/src/Dict.cc b/src/Dict.cc index 2536073e86..f4144fb464 100644 --- a/src/Dict.cc +++ b/src/Dict.cc @@ -95,11 +95,11 @@ TEST_CASE("dict operation") uint32_t val = 10; uint32_t key_val = 5; - zeek::detail::HashKey* key = new zeek::detail::HashKey(key_val); + detail::HashKey* key = new detail::HashKey(key_val); dict.Insert(key, &val); CHECK(dict.Length() == 1); - zeek::detail::HashKey* key2 = new zeek::detail::HashKey(key_val); + detail::HashKey* key2 = new detail::HashKey(key_val); uint32_t* lookup = dict.Lookup(key2); CHECK(*lookup == val); @@ -120,7 +120,7 @@ TEST_CASE("dict operation") uint32_t val2 = 15; uint32_t key_val2 = 25; - key2 = new zeek::detail::HashKey(key_val2); + key2 = new detail::HashKey(key_val2); dict.Insert(key, &val); dict.Insert(key2, &val2); @@ -141,13 +141,13 @@ TEST_CASE("dict nthentry") uint32_t val = 15; uint32_t key_val = 5; - zeek::detail::HashKey* okey = new zeek::detail::HashKey(key_val); - zeek::detail::HashKey* ukey = new zeek::detail::HashKey(key_val); + detail::HashKey* okey = new detail::HashKey(key_val); + detail::HashKey* ukey = new detail::HashKey(key_val); uint32_t val2 = 10; uint32_t key_val2 = 25; - zeek::detail::HashKey* okey2 = new zeek::detail::HashKey(key_val2); - zeek::detail::HashKey* ukey2 = new zeek::detail::HashKey(key_val2); + detail::HashKey* okey2 = new detail::HashKey(key_val2); + detail::HashKey* ukey2 = new detail::HashKey(key_val2); unordered.Insert(ukey, &val); unordered.Insert(ukey2, &val2); @@ -176,16 +176,16 @@ TEST_CASE("dict iteration") uint32_t val = 15; uint32_t key_val = 5; - zeek::detail::HashKey* key = new zeek::detail::HashKey(key_val); + detail::HashKey* key = new detail::HashKey(key_val); uint32_t val2 = 10; uint32_t key_val2 = 25; - zeek::detail::HashKey* key2 = new zeek::detail::HashKey(key_val2); + detail::HashKey* key2 = new detail::HashKey(key_val2); dict.Insert(key, &val); dict.Insert(key2, &val2); - zeek::detail::HashKey* it_key; + detail::HashKey* it_key; IterCookie* it = dict.InitForIteration(); CHECK(it != nullptr); int count = 0; @@ -258,7 +258,7 @@ int Dictionary::ThresholdEntries() const return capacity - ( capacity >> detail::DICT_LOAD_FACTOR_BITS ); } -zeek::detail::hash_t Dictionary::FibHash(zeek::detail::hash_t h) const +detail::hash_t Dictionary::FibHash(detail::hash_t h) const { //GoldenRatio phi = (sqrt(5)+1)/2 = 1.6180339887... //1/phi = phi - 1 @@ -268,16 +268,16 @@ zeek::detail::hash_t Dictionary::FibHash(zeek::detail::hash_t h) const } // return position in dict with 2^bit size. -int Dictionary::BucketByHash(zeek::detail::hash_t h, int log2_table_size) const //map h to n-bit +int Dictionary::BucketByHash(detail::hash_t h, int log2_table_size) const //map h to n-bit { ASSERT(log2_table_size>=0); if ( ! log2_table_size ) return 0; //<< >> breaks on 64. #ifdef DICT_NO_FIB_HASH - zeek::detail::hash_t hash = h; + detail::hash_t hash = h; #else - zeek::detail::hash_t hash = FibHash(h); + detail::hash_t hash = FibHash(h); #endif int m = 64 - log2_table_size; @@ -619,12 +619,12 @@ void generic_delete_func(void* v) // Look up now also possibly modifies the entry. Why? if the entry is found but not positioned // according to the current dict (so it's before SizeUp), it will be moved to the right // position so next lookup is fast. -void* Dictionary::Lookup(const zeek::detail::HashKey* key) const +void* Dictionary::Lookup(const detail::HashKey* key) const { return Lookup(key->Key(), key->Size(), key->Hash()); } -void* Dictionary::Lookup(const void* key, int key_size, zeek::detail::hash_t h) const +void* Dictionary::Lookup(const void* key, int key_size, detail::hash_t h) const { Dictionary* d = const_cast(this); int position = d->LookupIndex(key, key_size, h); @@ -632,7 +632,7 @@ void* Dictionary::Lookup(const void* key, int key_size, zeek::detail::hash_t h) } //for verification purposes -int Dictionary::LinearLookupIndex(const void* key, int key_size, zeek::detail::hash_t hash) const +int Dictionary::LinearLookupIndex(const void* key, int key_size, detail::hash_t hash) const { for ( int i = 0; i < Capacity(); i++ ) if ( ! table[i].Empty() && table[i].Equal((const char*)key, key_size, hash) ) @@ -642,7 +642,7 @@ int Dictionary::LinearLookupIndex(const void* key, int key_size, zeek::detail::h // Lookup position for all possible table_sizes caused by remapping. Remap it immediately // if not in the middle of iteration. -int Dictionary::LookupIndex(const void* key, int key_size, zeek::detail::hash_t hash, int* insert_position, int* insert_distance) +int Dictionary::LookupIndex(const void* key, int key_size, detail::hash_t hash, int* insert_position, int* insert_distance) { ASSERT_VALID(this); if ( ! table ) @@ -696,7 +696,7 @@ int Dictionary::LookupIndex(const void* key, int key_size, zeek::detail::hash_t // position/distance if required. The starting point for the search may not be the bucket // for the current table size since this method is also used to search for an item in the // previous table size. -int Dictionary::LookupIndex(const void* key, int key_size, zeek::detail::hash_t hash, int bucket, int end, +int Dictionary::LookupIndex(const void* key, int key_size, detail::hash_t hash, int bucket, int end, int* insert_position/*output*/, int* insert_distance/*output*/) { ASSERT(bucket>=0 && bucket < Buckets()); @@ -719,7 +719,7 @@ int Dictionary::LookupIndex(const void* key, int key_size, zeek::detail::hash_t // Insert ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void* Dictionary::Insert(void* key, int key_size, zeek::detail::hash_t hash, void* val, bool copy_key) +void* Dictionary::Insert(void* key, int key_size, detail::hash_t hash, void* val, bool copy_key) { ASSERT_VALID(this); @@ -880,7 +880,7 @@ void Dictionary::SizeUp() // Remove ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void* Dictionary::Remove(const void* key, int key_size, zeek::detail::hash_t hash, bool dont_delete) +void* Dictionary::Remove(const void* key, int key_size, detail::hash_t hash, bool dont_delete) {//cookie adjustment: maintain inserts here. maintain next in lower level version. ASSERT_VALID(this); ASSERT(num_iterators == 0 || (cookies && cookies->size() == num_iterators)); //only robust iterators exist. @@ -1050,7 +1050,7 @@ void Dictionary::StopIterationNonConst(IterCookie* cookie) //const delete cookie; } -void* Dictionary::NextEntryNonConst(zeek::detail::HashKey*& h, IterCookie*& c, bool return_hash) //const +void* Dictionary::NextEntryNonConst(detail::HashKey*& h, IterCookie*& c, bool return_hash) //const { // If there are any inserted entries, return them first. // That keeps the list small and helps avoiding searching @@ -1072,7 +1072,7 @@ void* Dictionary::NextEntryNonConst(zeek::detail::HashKey*& h, IterCookie*& c, b // and removing from the tail is cheaper. detail::DictEntry e = c->inserted->back(); if ( return_hash ) - h = new zeek::detail::HashKey(e.GetKey(), e.key_size, e.hash); + h = new detail::HashKey(e.GetKey(), e.key_size, e.hash); void* v = e.value; c->inserted->pop_back(); return v; @@ -1120,7 +1120,7 @@ void* Dictionary::NextEntryNonConst(zeek::detail::HashKey*& h, IterCookie*& c, b ASSERT(! table[c->next].Empty()); void* v = table[c->next].value; if ( return_hash ) - h = new zeek::detail::HashKey(table[c->next].GetKey(), table[c->next].key_size, table[c->next].hash); + h = new detail::HashKey(table[c->next].GetKey(), table[c->next].key_size, table[c->next].hash); //prepare for next time. c->next = Next(c->next); @@ -1134,7 +1134,7 @@ IterCookie* Dictionary::InitForIteration() const return dp->InitForIterationNonConst(); } -void* Dictionary::NextEntry(zeek::detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const +void* Dictionary::NextEntry(detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const { Dictionary* dp = const_cast(this); return dp->NextEntryNonConst(h, cookie, return_hash); diff --git a/src/Dict.h b/src/Dict.h index e02c96ee33..61280a3cdc 100644 --- a/src/Dict.h +++ b/src/Dict.h @@ -74,7 +74,7 @@ public: char* key; }; - DictEntry(void* arg_key, int key_size = 0, zeek::detail::hash_t hash = 0, void* value = nullptr, + DictEntry(void* arg_key, int key_size = 0, hash_t hash = 0, void* value = nullptr, int16_t d = TOO_FAR_TO_REACH, bool copy_key = false) : distance(d), key_size(key_size), hash((uint32_t)hash), value(value) { @@ -121,7 +121,7 @@ public: const char* GetKey() const { return key_size <= 8 ? key_here : key; } - bool Equal(const char* arg_key, int arg_key_size, zeek::detail::hash_t arg_hash) const + bool Equal(const char* arg_key, int arg_key_size, hash_t arg_hash) const {//only 40-bit hash comparison. return ( 0 == ((hash ^ arg_hash) & HASH_MASK) ) && key_size == arg_key_size && 0 == memcmp(GetKey(), arg_key, key_size); @@ -160,24 +160,24 @@ public: // which takes a zeek::detail::HashKey, and the other which takes a raw key, // its size, and its (unmodulated) hash. //lookup may move the key to right place if in the old zone to speed up the next lookup. - void* Lookup(const zeek::detail::HashKey* key) const; - void* Lookup(const void* key, int key_size, zeek::detail::hash_t h) const; + void* Lookup(const detail::HashKey* key) const; + void* Lookup(const void* key, int key_size, detail::hash_t h) const; // Returns previous value, or 0 if none. - void* Insert(zeek::detail::HashKey* key, void* val) + void* Insert(detail::HashKey* key, void* val) { return Insert(key->TakeKey(), key->Size(), key->Hash(), val, false); } // If copy_key is true, then the key is copied, otherwise it's assumed // that it's a heap pointer that now belongs to the Dictionary to // manage as needed. - void* Insert(void* key, int key_size, zeek::detail::hash_t hash, void* val, bool copy_key); + void* Insert(void* key, int key_size, detail::hash_t hash, void* val, bool copy_key); // Removes the given element. Returns a pointer to the element in // case it needs to be deleted. Returns 0 if no such element exists. // If dontdelete is true, the key's bytes will not be deleted. - void* Remove(const zeek::detail::HashKey* key) + void* Remove(const detail::HashKey* key) { return Remove(key->Key(), key->Size(), key->Hash()); } - void* Remove(const void* key, int key_size, zeek::detail::hash_t hash, bool dont_delete = false); + void* Remove(const void* key, int key_size, detail::hash_t hash, bool dont_delete = false); // Number of entries. int Length() const @@ -222,7 +222,7 @@ public: // If return_hash is true, a HashKey for the entry is returned in h, // which should be delete'd when no longer needed. IterCookie* InitForIteration() const; - void* NextEntry(zeek::detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const; + void* NextEntry(detail::HashKey*& h, IterCookie*& cookie, bool return_hash) const; void StopIteration(IterCookie* cookie) const; void SetDeleteFunc(dict_delete_func f) { delete_func = f; } @@ -262,10 +262,10 @@ private: int ThresholdEntries() const; // Used to improve the distribution of the original hash. - zeek::detail::hash_t FibHash(zeek::detail::hash_t h) const; + detail::hash_t FibHash(detail::hash_t h) const; // Maps a hash to the appropriate n-bit table bucket. - int BucketByHash(zeek::detail::hash_t h, int bit) const; + int BucketByHash(detail::hash_t h, int bit) const; // Given a position of a non-empty item in the table, find the related bucket. int BucketByPosition(int position) const; @@ -297,14 +297,14 @@ private: //Iteration IterCookie* InitForIterationNonConst(); - void* NextEntryNonConst(zeek::detail::HashKey*& h, IterCookie*& cookie, bool return_hash); + void* NextEntryNonConst(detail::HashKey*& h, IterCookie*& cookie, bool return_hash); void StopIterationNonConst(IterCookie* cookie); //Lookup - int LinearLookupIndex(const void* key, int key_size, zeek::detail::hash_t hash) const; - int LookupIndex(const void* key, int key_size, zeek::detail::hash_t hash, int* insert_position = nullptr, + int LinearLookupIndex(const void* key, int key_size, detail::hash_t hash) const; + int LookupIndex(const void* key, int key_size, detail::hash_t hash, int* insert_position = nullptr, int* insert_distance = nullptr); - int LookupIndex(const void* key, int key_size, zeek::detail::hash_t hash, int begin, int end, + int LookupIndex(const void* key, int key_size, detail::hash_t hash, int begin, int end, int* insert_position = nullptr, int* insert_distance = nullptr); /// Insert entry, Adjust cookies when necessary. @@ -375,17 +375,17 @@ public: Dictionary(ordering, initial_size) {} T* Lookup(const char* key) const { - zeek::detail::HashKey h(key); + detail::HashKey h(key); return (T*) Dictionary::Lookup(&h); } - T* Lookup(const zeek::detail::HashKey* key) const + T* Lookup(const detail::HashKey* key) const { return (T*) Dictionary::Lookup(key); } T* Insert(const char* key, T* val) { - zeek::detail::HashKey h(key); + detail::HashKey h(key); return (T*) Dictionary::Insert(&h, (void*) val); } - T* Insert(zeek::detail::HashKey* key, T* val) + T* Insert(detail::HashKey* key, T* val) { return (T*) Dictionary::Insert(key, (void*) val); } T* NthEntry(int n) const { return (T*) Dictionary::NthEntry(n); } @@ -396,14 +396,14 @@ public: } T* NextEntry(IterCookie*& cookie) const { - zeek::detail::HashKey* h; + detail::HashKey* h; return (T*) Dictionary::NextEntry(h, cookie, false); } - T* NextEntry(zeek::detail::HashKey*& h, IterCookie*& cookie) const + T* NextEntry(detail::HashKey*& h, IterCookie*& cookie) const { return (T*) Dictionary::NextEntry(h, cookie, true); } - T* RemoveEntry(const zeek::detail::HashKey* key) + T* RemoveEntry(const detail::HashKey* key) { return (T*) Remove(key->Key(), key->Size(), key->Hash()); } - T* RemoveEntry(const zeek::detail::HashKey& key) + T* RemoveEntry(const detail::HashKey& key) { return (T*) Remove(key.Key(), key.Size(), key.Hash()); } }; diff --git a/src/Discard.cc b/src/Discard.cc index d1145d2462..3738706f26 100644 --- a/src/Discard.cc +++ b/src/Discard.cc @@ -18,12 +18,12 @@ namespace zeek::detail { Discarder::Discarder() { - check_ip = zeek::id::find_func("discarder_check_ip"); - check_tcp = zeek::id::find_func("discarder_check_tcp"); - check_udp = zeek::id::find_func("discarder_check_udp"); - check_icmp = zeek::id::find_func("discarder_check_icmp"); + check_ip = id::find_func("discarder_check_ip"); + check_tcp = id::find_func("discarder_check_tcp"); + check_udp = id::find_func("discarder_check_udp"); + check_icmp = id::find_func("discarder_check_icmp"); - discarder_maxlen = static_cast(zeek::id::find_val("discarder_maxlen")->AsCount()); + discarder_maxlen = static_cast(id::find_val("discarder_maxlen")->AsCount()); } Discarder::~Discarder() @@ -35,7 +35,7 @@ bool Discarder::IsActive() return check_ip || check_tcp || check_udp || check_icmp; } -bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) +bool Discarder::NextPacket(const IP_Hdr* ip, int len, int caplen) { bool discard_packet = false; @@ -48,7 +48,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) discard_packet = check_ip->Invoke(&args)->AsBool(); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { discard_packet = false; } @@ -95,7 +95,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) zeek::Args args{ ip->ToPktHdrVal(), - {zeek::AdoptRef{}, BuildData(data, th_len, len, caplen)}, + {AdoptRef{}, BuildData(data, th_len, len, caplen)}, }; try @@ -103,7 +103,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) discard_packet = check_tcp->Invoke(&args)->AsBool(); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { discard_packet = false; } @@ -119,7 +119,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) zeek::Args args{ ip->ToPktHdrVal(), - {zeek::AdoptRef{}, BuildData(data, uh_len, len, caplen)}, + {AdoptRef{}, BuildData(data, uh_len, len, caplen)}, }; try @@ -127,7 +127,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) discard_packet = check_udp->Invoke(&args)->AsBool(); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { discard_packet = false; } @@ -147,7 +147,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) discard_packet = check_icmp->Invoke(&args)->AsBool(); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { discard_packet = false; } @@ -157,7 +157,7 @@ bool Discarder::NextPacket(const zeek::IP_Hdr* ip, int len, int caplen) return discard_packet; } -zeek::Val* Discarder::BuildData(const u_char* data, int hdrlen, int len, int caplen) +Val* Discarder::BuildData(const u_char* data, int hdrlen, int len, int caplen) { len -= hdrlen; caplen -= hdrlen; @@ -165,7 +165,7 @@ zeek::Val* Discarder::BuildData(const u_char* data, int hdrlen, int len, int cap len = std::max(std::min(std::min(len, caplen), discarder_maxlen), 0); - return new zeek::StringVal(new zeek::String(data, len, true)); + return new StringVal(new String(data, len, true)); } } // namespace zeek::detail diff --git a/src/Discard.h b/src/Discard.h index c721f9c8cf..977f2fa724 100644 --- a/src/Discard.h +++ b/src/Discard.h @@ -11,7 +11,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Func, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(Val, zeek); namespace zeek { -using FuncPtr = zeek::IntrusivePtr; +using FuncPtr = IntrusivePtr; namespace detail { @@ -22,15 +22,15 @@ public: bool IsActive(); - bool NextPacket(const zeek::IP_Hdr* ip, int len, int caplen); + bool NextPacket(const IP_Hdr* ip, int len, int caplen); protected: - zeek::Val* BuildData(const u_char* data, int hdrlen, int len, int caplen); + Val* BuildData(const u_char* data, int hdrlen, int len, int caplen); - zeek::FuncPtr check_ip; - zeek::FuncPtr check_tcp; - zeek::FuncPtr check_udp; - zeek::FuncPtr check_icmp; + FuncPtr check_ip; + FuncPtr check_tcp; + FuncPtr check_udp; + FuncPtr check_icmp; // Maximum amount of application data passed to filtering functions. int discarder_maxlen; diff --git a/src/EquivClass.cc b/src/EquivClass.cc index c9f01c455f..303c2b3161 100644 --- a/src/EquivClass.cc +++ b/src/EquivClass.cc @@ -189,7 +189,7 @@ void EquivClass::Dump(FILE* f) int EquivClass::Size() const { - return padded_sizeof(*this) + zeek::util::pad_size(sizeof(int) * size * (ccl_flags ? 5 : 4)); + return padded_sizeof(*this) + util::pad_size(sizeof(int) * size * (ccl_flags ? 5 : 4)); } } // namespace zeek::detail diff --git a/src/Event.cc b/src/Event.cc index c2d5528e3d..9b1b7b0127 100644 --- a/src/Event.cc +++ b/src/Event.cc @@ -18,8 +18,8 @@ zeek::EventMgr& mgr = zeek::event_mgr; namespace zeek { -Event::Event(EventHandlerPtr arg_handler, zeek::Args arg_args, - zeek::util::detail::SourceID arg_src, zeek::analyzer::ID arg_aid, + Event::Event(EventHandlerPtr arg_handler, zeek::Args arg_args, + util::detail::SourceID arg_src, analyzer::ID arg_aid, Obj* arg_obj) : handler(arg_handler), args(std::move(arg_args)), @@ -49,18 +49,18 @@ void Event::Describe(ODesc* d) const void Event::Dispatch(bool no_remote) { - if ( src == zeek::util::detail::SOURCE_BROKER ) + if ( src == util::detail::SOURCE_BROKER ) no_remote = true; if ( handler->ErrorHandler() ) - zeek::reporter->BeginErrorHandler(); + reporter->BeginErrorHandler(); try { handler->Call(&args, no_remote); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { // Already reported. } @@ -70,13 +70,13 @@ void Event::Dispatch(bool no_remote) Unref(obj); if ( handler->ErrorHandler() ) - zeek::reporter->EndErrorHandler(); + reporter->EndErrorHandler(); } EventMgr::EventMgr() { head = tail = nullptr; - current_src = zeek::util::detail::SOURCE_LOCAL; + current_src = util::detail::SOURCE_LOCAL; current_aid = 0; src_val = nullptr; draining = false; @@ -95,36 +95,36 @@ EventMgr::~EventMgr() } void EventMgr::QueueEventFast(const EventHandlerPtr &h, ValPList vl, - zeek::util::detail::SourceID src, analyzer::ID aid, zeek::detail::TimerMgr* mgr, + util::detail::SourceID src, analyzer::ID aid, detail::TimerMgr* mgr, Obj* obj) { - QueueEvent(new Event(h, zeek::val_list_to_args(vl), src, aid, obj)); + QueueEvent(new Event(h, val_list_to_args(vl), src, aid, obj)); } void EventMgr::QueueEvent(const EventHandlerPtr &h, ValPList vl, - zeek::util::detail::SourceID src, analyzer::ID aid, - zeek::detail::TimerMgr* mgr, Obj* obj) + util::detail::SourceID src, analyzer::ID aid, + detail::TimerMgr* mgr, Obj* obj) { - auto args = zeek::val_list_to_args(vl); + auto args = val_list_to_args(vl); if ( h ) Enqueue(h, std::move(args), src, aid, obj); } void EventMgr::QueueEvent(const EventHandlerPtr &h, ValPList* vl, - zeek::util::detail::SourceID src, analyzer::ID aid, - zeek::detail::TimerMgr* mgr, Obj* obj) + util::detail::SourceID src, analyzer::ID aid, + detail::TimerMgr* mgr, Obj* obj) { - auto args = zeek::val_list_to_args(*vl); + auto args = val_list_to_args(*vl); delete vl; if ( h ) Enqueue(h, std::move(args), src, aid, obj); } -void EventMgr::Enqueue(const EventHandlerPtr& h, zeek::Args vl, - zeek::util::detail::SourceID src, - zeek::analyzer::ID aid, Obj* obj) +void EventMgr::Enqueue(const EventHandlerPtr& h, Args vl, + util::detail::SourceID src, + analyzer::ID aid, Obj* obj) { QueueEvent(new Event(h, std::move(vl), src, aid, obj)); } @@ -160,9 +160,9 @@ void EventMgr::Dispatch(Event* event, bool no_remote) void EventMgr::Drain() { if ( event_queue_flush_point ) - Enqueue(event_queue_flush_point, zeek::Args{}); + Enqueue(event_queue_flush_point, Args{}); - zeek::detail::SegmentProfiler prof(zeek::detail::segment_logger, "draining-events"); + detail::SegmentProfiler prof(detail::segment_logger, "draining-events"); PLUGIN_HOOK_VOID(HOOK_DRAIN_EVENTS, HookDrainEvents()); @@ -201,7 +201,7 @@ void EventMgr::Drain() // Make sure all of the triggers get processed every time the events // drain. - zeek::detail::trigger_mgr->Process(); + detail::trigger_mgr->Process(); } void EventMgr::Describe(ODesc* d) const @@ -225,9 +225,9 @@ void EventMgr::Process() // If we don't have a source, or the source is closed, or we're // reading live (which includes pseudo-realtime), advance the time // here to the current time since otherwise it won't move forward. - zeek::iosource::PktSrc* pkt_src = zeek::iosource_mgr->GetPktSrc(); - if ( ! pkt_src || ! pkt_src->IsOpen() || zeek::run_state::reading_live ) - zeek::run_state::detail::update_network_time(zeek::util::current_time()); + iosource::PktSrc* pkt_src = iosource_mgr->GetPktSrc(); + if ( ! pkt_src || ! pkt_src->IsOpen() || run_state::reading_live ) + run_state::detail::update_network_time(util::current_time()); queue_flare.Extinguish(); @@ -242,9 +242,9 @@ void EventMgr::Process() void EventMgr::InitPostScript() { - zeek::iosource_mgr->Register(this, true, false); - if ( ! zeek::iosource_mgr->RegisterFd(queue_flare.FD(), this) ) - zeek::reporter->FatalError("Failed to register event manager FD with zeek::iosource_mgr"); + iosource_mgr->Register(this, true, false); + if ( ! iosource_mgr->RegisterFd(queue_flare.FD(), this) ) + reporter->FatalError("Failed to register event manager FD with iosource_mgr"); } } // namespace zeek diff --git a/src/Event.h b/src/Event.h index 97f942e541..76b937bf9a 100644 --- a/src/Event.h +++ b/src/Event.h @@ -16,17 +16,17 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(EventMgr, zeek); namespace zeek { -class Event final : public zeek::Obj { +class Event final : public Obj { public: Event(EventHandlerPtr handler, zeek::Args args, - zeek::util::detail::SourceID src = zeek::util::detail::SOURCE_LOCAL, zeek::analyzer::ID aid = 0, - zeek::Obj* obj = nullptr); + util::detail::SourceID src = util::detail::SOURCE_LOCAL, analyzer::ID aid = 0, + Obj* obj = nullptr); void SetNext(Event* n) { next_event = n; } Event* NextEvent() const { return next_event; } - zeek::util::detail::SourceID Source() const { return src; } - zeek::analyzer::ID Analyzer() const { return aid; } + util::detail::SourceID Source() const { return src; } + analyzer::ID Analyzer() const { return aid; } EventHandlerPtr Handler() const { return handler; } const zeek::Args& Args() const { return args; } @@ -41,13 +41,13 @@ protected: EventHandlerPtr handler; zeek::Args args; - zeek::util::detail::SourceID src; - zeek::analyzer::ID aid; - zeek::Obj* obj; + util::detail::SourceID src; + analyzer::ID aid; + Obj* obj; Event* next_event; }; -class EventMgr final : public zeek::Obj, public iosource::IOSource { +class EventMgr final : public Obj, public iosource::IOSource { public: EventMgr(); ~EventMgr() override; @@ -62,8 +62,8 @@ public: // arguments when there's no handlers to consume them). [[deprecated("Remove in v4.1. Use Enqueue() instead.")]] void QueueEventFast(const EventHandlerPtr &h, ValPList vl, - zeek::util::detail::SourceID src = zeek::util::detail::SOURCE_LOCAL, zeek::analyzer::ID aid = 0, - zeek::detail::TimerMgr* mgr = nullptr, zeek::Obj* obj = nullptr); + util::detail::SourceID src = util::detail::SOURCE_LOCAL, analyzer::ID aid = 0, + detail::TimerMgr* mgr = nullptr, Obj* obj = nullptr); // Queues an event if there's an event handler (or remote consumer). This // function always takes ownership of decrementing the reference count of @@ -73,8 +73,8 @@ public: // existence check. [[deprecated("Remove in v4.1. Use Enqueue() instead.")]] void QueueEvent(const EventHandlerPtr &h, ValPList vl, - zeek::util::detail::SourceID src = zeek::util::detail::SOURCE_LOCAL, zeek::analyzer::ID aid = 0, - zeek::detail::TimerMgr* mgr = nullptr, zeek::Obj* obj = nullptr); + util::detail::SourceID src = util::detail::SOURCE_LOCAL, analyzer::ID aid = 0, + detail::TimerMgr* mgr = nullptr, Obj* obj = nullptr); // Same as QueueEvent, except taking the event's argument list via a // pointer instead of by value. This function takes ownership of the @@ -82,8 +82,8 @@ public: // each of its elements. [[deprecated("Remove in v4.1. Use Enqueue() instead.")]] void QueueEvent(const EventHandlerPtr &h, ValPList* vl, - zeek::util::detail::SourceID src = zeek::util::detail::SOURCE_LOCAL, zeek::analyzer::ID aid = 0, - zeek::detail::TimerMgr* mgr = nullptr, zeek::Obj* obj = nullptr); + util::detail::SourceID src = util::detail::SOURCE_LOCAL, analyzer::ID aid = 0, + detail::TimerMgr* mgr = nullptr, Obj* obj = nullptr); /** * Adds an event to the queue. If no handler is found for the event @@ -98,8 +98,8 @@ public: * reference to until dispatching the event. */ void Enqueue(const EventHandlerPtr& h, zeek::Args vl, - zeek::util::detail::SourceID src = zeek::util::detail::SOURCE_LOCAL, zeek::analyzer::ID aid = 0, - zeek::Obj* obj = nullptr); + util::detail::SourceID src = util::detail::SOURCE_LOCAL, analyzer::ID aid = 0, + Obj* obj = nullptr); /** * A version of Enqueue() taking a variable number of arguments. @@ -107,7 +107,7 @@ public: template std::enable_if_t< std::is_convertible_v< - std::tuple_element_t<0, std::tuple>, zeek::ValPtr>> + std::tuple_element_t<0, std::tuple>, ValPtr>> Enqueue(const EventHandlerPtr& h, Args&&... args) { return Enqueue(h, zeek::Args{std::forward(args)...}); } @@ -119,11 +119,11 @@ public: bool HasEvents() const { return head != nullptr; } // Returns the source ID of last raised event. - zeek::util::detail::SourceID CurrentSource() const { return current_src; } + util::detail::SourceID CurrentSource() const { return current_src; } // Returns the ID of the analyzer which raised the last event, or 0 if // non-analyzer event. - zeek::analyzer::ID CurrentAnalyzer() const { return current_aid; } + analyzer::ID CurrentAnalyzer() const { return current_aid; } int Size() const { return num_events_queued - num_events_dispatched; } @@ -143,11 +143,11 @@ protected: Event* head; Event* tail; - zeek::util::detail::SourceID current_src; - zeek::analyzer::ID current_aid; - zeek::RecordVal* src_val; + util::detail::SourceID current_src; + analyzer::ID current_aid; + RecordVal* src_val; bool draining; - zeek::detail::Flare queue_flare; + detail::Flare queue_flare; }; extern EventMgr event_mgr; diff --git a/src/EventHandler.cc b/src/EventHandler.cc index b28d891575..271b19a58d 100644 --- a/src/EventHandler.cc +++ b/src/EventHandler.cc @@ -28,31 +28,31 @@ EventHandler::operator bool() const || ! auto_publish.empty()); } -const zeek::FuncTypePtr& EventHandler::GetType(bool check_export) +const FuncTypePtr& EventHandler::GetType(bool check_export) { if ( type ) return type; - const auto& id = zeek::detail::lookup_ID(name.data(), zeek::detail::current_module.c_str(), - false, false, check_export); + const auto& id = detail::lookup_ID(name.data(), detail::current_module.c_str(), + false, false, check_export); if ( ! id ) - return zeek::FuncType::nil; + return FuncType::nil; - if ( id->GetType()->Tag() != zeek::TYPE_FUNC ) - return zeek::FuncType::nil; + if ( id->GetType()->Tag() != TYPE_FUNC ) + return FuncType::nil; - type = id->GetType(); + type = id->GetType(); return type; } -void EventHandler::SetFunc(zeek::FuncPtr f) +void EventHandler::SetFunc(FuncPtr f) { local = std::move(f); } -void EventHandler::SetLocalHandler(zeek::Func* f) - { SetFunc({zeek::NewRef{}, f}); } +void EventHandler::SetLocalHandler(Func* f) + { SetFunc({NewRef{}, f}); } -void EventHandler::Call(zeek::Args* vl, bool no_remote) +void EventHandler::Call(Args* vl, bool no_remote) { #ifdef PROFILE_BRO_FUNCTIONS DEBUG_MSG("Event: %s\n", Name()); @@ -72,7 +72,7 @@ void EventHandler::Call(zeek::Args* vl, bool no_remote) for ( auto i = 0u; i < vl->size(); ++i ) { - auto opt_data = zeek::Broker::detail::val_to_data((*vl)[i].get()); + auto opt_data = Broker::detail::val_to_data((*vl)[i].get()); if ( opt_data ) xs.emplace_back(std::move(*opt_data)); @@ -80,7 +80,7 @@ void EventHandler::Call(zeek::Args* vl, bool no_remote) { valid_args = false; auto_publish.clear(); - zeek::reporter->Error("failed auto-remote event '%s', disabled", Name()); + reporter->Error("failed auto-remote event '%s', disabled", Name()); break; } } @@ -109,7 +109,7 @@ void EventHandler::Call(zeek::Args* vl, bool no_remote) local->Invoke(vl); } -void EventHandler::NewEvent(zeek::Args* vl) +void EventHandler::NewEvent(Args* vl) { if ( ! new_event ) return; @@ -118,13 +118,13 @@ void EventHandler::NewEvent(zeek::Args* vl) // new_event() is the one event we don't want to report. return; - auto vargs = zeek::MakeCallArgumentVector(*vl, GetType()->Params()); + auto vargs = MakeCallArgumentVector(*vl, GetType()->Params()); - auto ev = new zeek::Event(new_event, { - zeek::make_intrusive(name), + auto ev = new Event(new_event, { + make_intrusive(name), std::move(vargs), }); - zeek::event_mgr.Dispatch(ev); + event_mgr.Dispatch(ev); } } // namespace zeek diff --git a/src/EventHandler.h b/src/EventHandler.h index c211a1fbdb..b8000167aa 100644 --- a/src/EventHandler.h +++ b/src/EventHandler.h @@ -12,7 +12,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Func, zeek); namespace zeek { -using FuncPtr = zeek::IntrusivePtr; +using FuncPtr = IntrusivePtr; class EventHandler { public: @@ -20,22 +20,22 @@ public: const char* Name() { return name.data(); } - const zeek::FuncPtr& GetFunc() + const FuncPtr& GetFunc() { return local; } [[deprecated("Remove in v4.1. Use GetFunc().")]] - zeek::Func* LocalHandler() { return local.get(); } + Func* LocalHandler() { return local.get(); } - const zeek::FuncTypePtr& GetType(bool check_export = true); + const FuncTypePtr& GetType(bool check_export = true); [[deprecated("Remove in v4.1. Use GetType().")]] - zeek::FuncType* FType(bool check_export = true) + FuncType* FType(bool check_export = true) { return GetType().get(); } - void SetFunc(zeek::FuncPtr f); + void SetFunc(FuncPtr f); [[deprecated("Remove in v4.1. Use SetFunc().")]] - void SetLocalHandler(zeek::Func* f); + void SetLocalHandler(Func* f); void AutoPublish(std::string topic) { @@ -71,8 +71,8 @@ private: void NewEvent(zeek::Args* vl); // Raise new_event() meta event. std::string name; - zeek::FuncPtr local; - zeek::FuncTypePtr type; + FuncPtr local; + FuncTypePtr type; bool used; // this handler is indeed used somewhere bool enabled; bool error_handler; // this handler reports error messages. diff --git a/src/EventRegistry.cc b/src/EventRegistry.cc index 36529f9b0f..0ed355f9ff 100644 --- a/src/EventRegistry.cc +++ b/src/EventRegistry.cc @@ -9,11 +9,11 @@ namespace zeek { EventRegistry::EventRegistry() = default; EventRegistry::~EventRegistry() noexcept = default; -zeek::EventHandlerPtr EventRegistry::Register(std::string_view name) +EventHandlerPtr EventRegistry::Register(std::string_view name) { // If there already is an entry in the registry, we have a // local handler on the script layer. - zeek::EventHandler* h = event_registry->Lookup(name); + EventHandler* h = event_registry->Lookup(name); if ( h ) { @@ -21,7 +21,7 @@ zeek::EventHandlerPtr EventRegistry::Register(std::string_view name) return h; } - h = new zeek::EventHandler(std::string(name)); + h = new EventHandler(std::string(name)); event_registry->Register(h); h->SetUsed(); @@ -29,12 +29,12 @@ zeek::EventHandlerPtr EventRegistry::Register(std::string_view name) return h; } -void EventRegistry::Register(zeek::EventHandlerPtr handler) +void EventRegistry::Register(EventHandlerPtr handler) { - handlers[std::string(handler->Name())] = std::unique_ptr(handler.Ptr()); + handlers[std::string(handler->Name())] = std::unique_ptr(handler.Ptr()); } -zeek::EventHandler* EventRegistry::Lookup(std::string_view name) +EventHandler* EventRegistry::Lookup(std::string_view name) { auto it = handlers.find(name); if ( it != handlers.end() ) @@ -43,13 +43,13 @@ zeek::EventHandler* EventRegistry::Lookup(std::string_view name) return nullptr; } -EventRegistry::string_list EventRegistry::Match(zeek::RE_Matcher* pattern) +EventRegistry::string_list EventRegistry::Match(RE_Matcher* pattern) { string_list names; for ( const auto& entry : handlers ) { - zeek::EventHandler* v = entry.second.get(); + EventHandler* v = entry.second.get(); if ( v->GetFunc() && pattern->MatchExactly(v->Name()) ) names.push_back(entry.first); } @@ -63,7 +63,7 @@ EventRegistry::string_list EventRegistry::UnusedHandlers() for ( const auto& entry : handlers ) { - zeek::EventHandler* v = entry.second.get(); + EventHandler* v = entry.second.get(); if ( v->GetFunc() && ! v->Used() ) names.push_back(entry.first); } @@ -77,7 +77,7 @@ EventRegistry::string_list EventRegistry::UsedHandlers() for ( const auto& entry : handlers ) { - zeek::EventHandler* v = entry.second.get(); + EventHandler* v = entry.second.get(); if ( v->GetFunc() && v->Used() ) names.push_back(entry.first); } @@ -101,7 +101,7 @@ void EventRegistry::PrintDebug() { for ( const auto& entry : handlers ) { - zeek::EventHandler* v = entry.second.get(); + EventHandler* v = entry.second.get(); fprintf(stderr, "Registered event %s (%s handler / %s)\n", v->Name(), v->GetFunc() ? "local" : "no", *v ? "active" : "not active" @@ -111,7 +111,7 @@ void EventRegistry::PrintDebug() void EventRegistry::SetErrorHandler(std::string_view name) { - zeek::EventHandler* eh = Lookup(name); + EventHandler* eh = Lookup(name); if ( eh ) { @@ -119,8 +119,8 @@ void EventRegistry::SetErrorHandler(std::string_view name) return; } - zeek::reporter->InternalWarning("unknown event handler '%s' in SetErrorHandler()", - std::string(name).c_str()); + reporter->InternalWarning("unknown event handler '%s' in SetErrorHandler()", + std::string(name).c_str()); } } // namespace zeek diff --git a/src/EventRegistry.h b/src/EventRegistry.h index 9e161a920d..88365a1e18 100644 --- a/src/EventRegistry.h +++ b/src/EventRegistry.h @@ -28,17 +28,17 @@ public: * @param name The name of the event handler to lookup/register. * @return The event handler. */ - zeek::EventHandlerPtr Register(std::string_view name); + EventHandlerPtr Register(std::string_view name); - void Register(zeek::EventHandlerPtr handler); + void Register(EventHandlerPtr handler); // Return nil if unknown. - zeek::EventHandler* Lookup(std::string_view name); + EventHandler* Lookup(std::string_view name); // Returns a list of all local handlers that match the given pattern. // Passes ownership of list. using string_list = std::vector; - string_list Match(zeek::RE_Matcher* pattern); + string_list Match(RE_Matcher* pattern); // Marks a handler as handling errors. Error handler will not be called // recursively to avoid infinite loops in case they trigger an error @@ -52,7 +52,7 @@ public: void PrintDebug(); private: - std::map, std::less<>> handlers; + std::map, std::less<>> handlers; }; extern EventRegistry* event_registry; diff --git a/src/Expr.cc b/src/Expr.cc index ee6a7b6abc..043e560f30 100644 --- a/src/Expr.cc +++ b/src/Expr.cc @@ -135,11 +135,11 @@ ExprPtr Expr::MakeLvalue() if ( ! IsError() ) ExprError("can't be assigned to"); - return {zeek::NewRef{}, this}; + return {NewRef{}, this}; } void Expr::EvalIntoAggregate(const zeek::Type* /* t */, Val* /* aggr */, - Frame* /* f */) const + Frame* /* f */) const { Internal("Expr::EvalIntoAggregate called"); } @@ -149,7 +149,7 @@ void Expr::Assign(Frame* /* f */, ValPtr /* v */) Internal("Expr::Assign called"); } -zeek::TypePtr Expr::InitType() const +TypePtr Expr::InitType() const { return type; } @@ -180,7 +180,7 @@ ValPtr Expr::InitVal(const zeek::Type* t, ValPtr aggr) const bool Expr::IsError() const { - return type && type->Tag() == zeek::TYPE_ERROR; + return type && type->Tag() == TYPE_ERROR; } void Expr::SetError() @@ -230,9 +230,9 @@ void Expr::Canonicize() { } -void Expr::SetType(zeek::TypePtr t) +void Expr::SetType(TypePtr t) { - if ( ! type || type->Tag() != zeek::TYPE_ERROR ) + if ( ! type || type->Tag() != TYPE_ERROR ) type = std::move(t); } @@ -244,7 +244,7 @@ void Expr::ExprError(const char msg[]) void Expr::RuntimeError(const std::string& msg) const { - zeek::reporter->ExprRuntimeError(this, "%s", msg.data()); + reporter->ExprRuntimeError(this, "%s", msg.data()); } void Expr::RuntimeErrorWithCallStack(const std::string& msg) const @@ -252,28 +252,28 @@ void Expr::RuntimeErrorWithCallStack(const std::string& msg) const auto rcs = render_call_stack(); if ( rcs.empty() ) - zeek::reporter->ExprRuntimeError(this, "%s", msg.data()); + reporter->ExprRuntimeError(this, "%s", msg.data()); else { ODesc d; d.SetShort(); Describe(&d); - zeek::reporter->RuntimeError(GetLocationInfo(), "%s, expression: %s, call stack: %s", + reporter->RuntimeError(GetLocationInfo(), "%s, expression: %s, call stack: %s", msg.data(), d.Description(), rcs.data()); } } -NameExpr::NameExpr(zeek::detail::IDPtr arg_id, bool const_init) +NameExpr::NameExpr(IDPtr arg_id, bool const_init) : Expr(EXPR_NAME), id(std::move(arg_id)) { in_const_init = const_init; if ( id->IsType() ) - SetType(zeek::make_intrusive(id->GetType())); + SetType(make_intrusive(id->GetType())); else SetType(id->GetType()); - EventHandler* h = zeek::event_registry->Lookup(id->Name()); + EventHandler* h = event_registry->Lookup(id->Name()); if ( h ) h->SetUsed(); } @@ -283,7 +283,7 @@ ValPtr NameExpr::Eval(Frame* f) const ValPtr v; if ( id->IsType() ) - return zeek::make_intrusive(id->GetType(), true); + return make_intrusive(id->GetType(), true); if ( id->IsGlobal() ) v = id->GetVal(); @@ -315,7 +315,7 @@ ExprPtr NameExpr::MakeLvalue() if ( id->IsOption() && ! in_const_init ) ExprError("option is not a modifiable lvalue"); - return zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, this}); + return make_intrusive(IntrusivePtr{NewRef{}, this}); } void NameExpr::Assign(Frame* f, ValPtr v) @@ -360,7 +360,7 @@ void NameExpr::ExprDescribe(ODesc* d) const ConstExpr::ConstExpr(ValPtr arg_val) : Expr(EXPR_CONST), val(std::move(arg_val)) { - if ( val->GetType()->Tag() == zeek::TYPE_LIST && val->AsListVal()->Length() == 1 ) + if ( val->GetType()->Tag() == TYPE_LIST && val->AsListVal()->Length() == 1 ) val = val->AsListVal()->Idx(0); SetType(val->GetType()); @@ -373,7 +373,7 @@ void ConstExpr::ExprDescribe(ODesc* d) const ValPtr ConstExpr::Eval(Frame* /* f */) const { - return {zeek::NewRef{}, Value()}; + return {NewRef{}, Value()}; } TraversalCode ConstExpr::Traverse(TraversalCallback* cb) const @@ -405,14 +405,14 @@ ValPtr UnaryExpr::Eval(Frame* f) const if ( is_vector(v) && Tag() != EXPR_IS && Tag() != EXPR_CAST ) { VectorVal* v_op = v->AsVectorVal(); - zeek::VectorTypePtr out_t; + VectorTypePtr out_t; - if ( GetType()->Tag() == zeek::TYPE_ANY ) - out_t = v->GetType(); + if ( GetType()->Tag() == TYPE_ANY ) + out_t = v->GetType(); else - out_t = GetType(); + out_t = GetType(); - auto result = zeek::make_intrusive(std::move(out_t)); + auto result = make_intrusive(std::move(out_t)); for ( unsigned int i = 0; i < v_op->Size(); ++i ) { @@ -447,7 +447,7 @@ TraversalCode UnaryExpr::Traverse(TraversalCallback* cb) const ValPtr UnaryExpr::Fold(Val* v) const { - return {zeek::NewRef{}, v}; + return {NewRef{}, v}; } void UnaryExpr::ExprDescribe(ODesc* d) const @@ -503,7 +503,7 @@ ValPtr BinaryExpr::Eval(Frame* f) const return nullptr; } - auto v_result = zeek::make_intrusive(GetType()); + auto v_result = make_intrusive(GetType()); for ( unsigned int i = 0; i < v_op1->Size(); ++i ) { @@ -520,7 +520,7 @@ ValPtr BinaryExpr::Eval(Frame* f) const if ( IsVector(GetType()->Tag()) && (is_vec1 || is_vec2) ) { // fold vector against scalar VectorVal* vv = (is_vec1 ? v1 : v2)->AsVectorVal(); - auto v_result = zeek::make_intrusive(GetType()); + auto v_result = make_intrusive(GetType()); for ( unsigned int i = 0; i < vv->Size(); ++i ) { @@ -575,19 +575,19 @@ ValPtr BinaryExpr::Fold(Val* v1, Val* v2) const { InternalTypeTag it = v1->GetType()->InternalType(); - if ( it == zeek::TYPE_INTERNAL_STRING ) + if ( it == TYPE_INTERNAL_STRING ) return StringFold(v1, v2); - if ( v1->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( v1->GetType()->Tag() == TYPE_PATTERN ) return PatternFold(v1, v2); if ( v1->GetType()->IsSet() ) return SetFold(v1, v2); - if ( it == zeek::TYPE_INTERNAL_ADDR ) + if ( it == TYPE_INTERNAL_ADDR ) return AddrFold(v1, v2); - if ( it == zeek::TYPE_INTERNAL_SUBNET ) + if ( it == TYPE_INTERNAL_SUBNET ) return SubNetFold(v1, v2); bro_int_t i1 = 0, i2 = 0, i3 = 0; @@ -596,19 +596,19 @@ ValPtr BinaryExpr::Fold(Val* v1, Val* v2) const bool is_integral = false; bool is_unsigned = false; - if ( it == zeek::TYPE_INTERNAL_INT ) + if ( it == TYPE_INTERNAL_INT ) { i1 = v1->InternalInt(); i2 = v2->InternalInt(); is_integral = true; } - else if ( it == zeek::TYPE_INTERNAL_UNSIGNED ) + else if ( it == TYPE_INTERNAL_UNSIGNED ) { u1 = v1->InternalUnsigned(); u2 = v2->InternalUnsigned(); is_unsigned = true; } - else if ( it == zeek::TYPE_INTERNAL_DOUBLE ) + else if ( it == TYPE_INTERNAL_DOUBLE ) { d1 = v1->InternalDouble(); d2 = v2->InternalDouble(); @@ -724,18 +724,18 @@ ValPtr BinaryExpr::Fold(Val* v1, Val* v2) const const auto& ret_type = IsVector(GetType()->Tag()) ? GetType()->Yield() : GetType(); - if ( ret_type->Tag() == zeek::TYPE_INTERVAL ) - return zeek::make_intrusive(d3); - else if ( ret_type->Tag() == zeek::TYPE_TIME ) - return zeek::make_intrusive(d3); - else if ( ret_type->Tag() == zeek::TYPE_DOUBLE ) - return zeek::make_intrusive(d3); - else if ( ret_type->InternalType() == zeek::TYPE_INTERNAL_UNSIGNED ) - return zeek::val_mgr->Count(u3); - else if ( ret_type->Tag() == zeek::TYPE_BOOL ) - return zeek::val_mgr->Bool(i3); + if ( ret_type->Tag() == TYPE_INTERVAL ) + return make_intrusive(d3); + else if ( ret_type->Tag() == TYPE_TIME ) + return make_intrusive(d3); + else if ( ret_type->Tag() == TYPE_DOUBLE ) + return make_intrusive(d3); + else if ( ret_type->InternalType() == TYPE_INTERNAL_UNSIGNED ) + return val_mgr->Count(u3); + else if ( ret_type->Tag() == TYPE_BOOL ) + return val_mgr->Bool(i3); else - return zeek::val_mgr->Int(i3); + return val_mgr->Int(i3); } ValPtr BinaryExpr::StringFold(Val* v1, Val* v2) const @@ -762,14 +762,14 @@ ValPtr BinaryExpr::StringFold(Val* v1, Val* v2) const strings.push_back(s1); strings.push_back(s2); - return zeek::make_intrusive(concatenate(strings)); + return make_intrusive(concatenate(strings)); } default: BadTag("BinaryExpr::StringFold", expr_name(tag)); } - return zeek::val_mgr->Bool(result); + return val_mgr->Bool(result); } @@ -785,7 +785,7 @@ ValPtr BinaryExpr::PatternFold(Val* v1, Val* v2) const RE_Matcher_conjunction(re1, re2) : RE_Matcher_disjunction(re1, re2); - return zeek::make_intrusive(res); + return make_intrusive(res); } ValPtr BinaryExpr::SetFold(Val* v1, Val* v2) const @@ -803,7 +803,7 @@ ValPtr BinaryExpr::SetFold(Val* v1, Val* v2) const auto rval = v1->Clone(); if ( ! tv2->AddTo(rval.get(), false, false) ) - zeek::reporter->InternalError("set union failed to type check"); + reporter->InternalError("set union failed to type check"); return rval; } @@ -813,7 +813,7 @@ ValPtr BinaryExpr::SetFold(Val* v1, Val* v2) const auto rval = v1->Clone(); if ( ! tv2->RemoveFrom(rval.get()) ) - zeek::reporter->InternalError("set difference failed to type check"); + reporter->InternalError("set difference failed to type check"); return rval; } @@ -837,7 +837,7 @@ ValPtr BinaryExpr::SetFold(Val* v1, Val* v2) const case EXPR_GE: case EXPR_GT: // These should't happen due to canonicalization. - zeek::reporter->InternalError("confusion over canonicalization in set comparison"); + reporter->InternalError("confusion over canonicalization in set comparison"); break; default: @@ -845,7 +845,7 @@ ValPtr BinaryExpr::SetFold(Val* v1, Val* v2) const return nullptr; } - return zeek::val_mgr->Bool(res); + return val_mgr->Bool(res); } ValPtr BinaryExpr::AddrFold(Val* v1, Val* v2) const @@ -879,7 +879,7 @@ ValPtr BinaryExpr::AddrFold(Val* v1, Val* v2) const BadTag("BinaryExpr::AddrFold", expr_name(tag)); } - return zeek::val_mgr->Bool(result); + return val_mgr->Bool(result); } ValPtr BinaryExpr::SubNetFold(Val* v1, Val* v2) const @@ -892,7 +892,7 @@ ValPtr BinaryExpr::SubNetFold(Val* v1, Val* v2) const if ( tag == EXPR_NE ) result = ! result; - return zeek::val_mgr->Bool(result); + return val_mgr->Bool(result); } void BinaryExpr::SwapOps() @@ -916,12 +916,12 @@ void BinaryExpr::PromoteOps(TypeTag t) bt2 = op2->GetType()->AsVectorType()->Yield()->Tag(); if ( (is_vec1 || is_vec2) && ! (is_vec1 && is_vec2) ) - zeek::reporter->Warning("mixing vector and scalar operands is deprecated"); + reporter->Warning("mixing vector and scalar operands is deprecated"); if ( bt1 != t ) - op1 = zeek::make_intrusive(op1, t); + op1 = make_intrusive(op1, t); if ( bt2 != t ) - op2 = zeek::make_intrusive(op2, t); + op2 = make_intrusive(op2, t); } void BinaryExpr::PromoteType(TypeTag t, bool is_vector) @@ -929,7 +929,7 @@ void BinaryExpr::PromoteType(TypeTag t, bool is_vector) PromoteOps(t); if ( is_vector) - SetType(zeek::make_intrusive(base_type(t))); + SetType(make_intrusive(base_type(t))); else SetType(base_type(t)); } @@ -973,7 +973,7 @@ IncrExpr::IncrExpr(BroExprTag arg_tag, ExprPtr arg_op) ExprError("vector elements must be integral for increment operator"); else { - zeek::reporter->Warning("increment/decrement operations for vectors deprecated"); + reporter->Warning("increment/decrement operations for vectors deprecated"); SetType(t); } } @@ -997,16 +997,16 @@ ValPtr IncrExpr::DoSingleEval(Frame* f, Val* v) const --k; if ( k < 0 && - v->GetType()->InternalType() == zeek::TYPE_INTERNAL_UNSIGNED ) + v->GetType()->InternalType() == TYPE_INTERNAL_UNSIGNED ) RuntimeError("count underflow"); } const auto& ret_type = IsVector(GetType()->Tag()) ? GetType()->Yield() : GetType(); - if ( ret_type->Tag() == zeek::TYPE_INT ) - return zeek::val_mgr->Int(k); + if ( ret_type->Tag() == TYPE_INT ) + return val_mgr->Int(k); else - return zeek::val_mgr->Count(k); + return val_mgr->Count(k); } @@ -1019,7 +1019,7 @@ ValPtr IncrExpr::Eval(Frame* f) const if ( is_vector(v) ) { - VectorValPtr v_vec{zeek::NewRef{}, v->AsVectorVal()}; + VectorValPtr v_vec{NewRef{}, v->AsVectorVal()}; for ( unsigned int i = 0; i < v_vec->Size(); ++i ) { @@ -1056,15 +1056,15 @@ ComplementExpr::ComplementExpr(ExprPtr arg_op) const auto& t = op->GetType(); TypeTag bt = t->Tag(); - if ( bt != zeek::TYPE_COUNT ) + if ( bt != TYPE_COUNT ) ExprError("requires \"count\" operand"); else - SetType(base_type(zeek::TYPE_COUNT)); + SetType(base_type(TYPE_COUNT)); } ValPtr ComplementExpr::Fold(Val* v) const { - return zeek::val_mgr->Count(~ v->InternalUnsigned()); + return val_mgr->Count(~ v->InternalUnsigned()); } NotExpr::NotExpr(ExprPtr arg_op) @@ -1075,15 +1075,15 @@ NotExpr::NotExpr(ExprPtr arg_op) TypeTag bt = op->GetType()->Tag(); - if ( ! IsIntegral(bt) && bt != zeek::TYPE_BOOL ) + if ( ! IsIntegral(bt) && bt != TYPE_BOOL ) ExprError("requires an integral or boolean operand"); else - SetType(base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } ValPtr NotExpr::Fold(Val* v) const { - return zeek::val_mgr->Bool(! v->InternalInt()); + return val_mgr->Bool(! v->InternalInt()); } PosExpr::PosExpr(ExprPtr arg_op) @@ -1095,18 +1095,18 @@ PosExpr::PosExpr(ExprPtr arg_op) const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType(); TypeTag bt = t->Tag(); - zeek::TypePtr base_result_type; + TypePtr base_result_type; if ( IsIntegral(bt) ) // Promote count and counter to int. - base_result_type = base_type(zeek::TYPE_INT); - else if ( bt == zeek::TYPE_INTERVAL || bt == zeek::TYPE_DOUBLE ) + base_result_type = base_type(TYPE_INT); + else if ( bt == TYPE_INTERVAL || bt == TYPE_DOUBLE ) base_result_type = t; else ExprError("requires an integral or double operand"); if ( is_vector(op) ) - SetType(zeek::make_intrusive(std::move(base_result_type))); + SetType(make_intrusive(std::move(base_result_type))); else SetType(std::move(base_result_type)); } @@ -1115,10 +1115,10 @@ ValPtr PosExpr::Fold(Val* v) const { TypeTag t = v->GetType()->Tag(); - if ( t == zeek::TYPE_DOUBLE || t == zeek::TYPE_INTERVAL || t == zeek::TYPE_INT ) - return {zeek::NewRef{}, v}; + if ( t == TYPE_DOUBLE || t == TYPE_INTERVAL || t == TYPE_INT ) + return {NewRef{}, v}; else - return zeek::val_mgr->Int(v->CoerceToInt()); + return val_mgr->Int(v->CoerceToInt()); } NegExpr::NegExpr(ExprPtr arg_op) @@ -1130,30 +1130,30 @@ NegExpr::NegExpr(ExprPtr arg_op) const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType(); TypeTag bt = t->Tag(); - zeek::TypePtr base_result_type; + TypePtr base_result_type; if ( IsIntegral(bt) ) // Promote count and counter to int. - base_result_type = base_type(zeek::TYPE_INT); - else if ( bt == zeek::TYPE_INTERVAL || bt == zeek::TYPE_DOUBLE ) + base_result_type = base_type(TYPE_INT); + else if ( bt == TYPE_INTERVAL || bt == TYPE_DOUBLE ) base_result_type = t; else ExprError("requires an integral or double operand"); if ( is_vector(op) ) - SetType(zeek::make_intrusive(std::move(base_result_type))); + SetType(make_intrusive(std::move(base_result_type))); else SetType(std::move(base_result_type)); } ValPtr NegExpr::Fold(Val* v) const { - if ( v->GetType()->Tag() == zeek::TYPE_DOUBLE ) - return zeek::make_intrusive(- v->InternalDouble()); - else if ( v->GetType()->Tag() == zeek::TYPE_INTERVAL ) - return zeek::make_intrusive(- v->InternalDouble()); + if ( v->GetType()->Tag() == TYPE_DOUBLE ) + return make_intrusive(- v->InternalDouble()); + else if ( v->GetType()->Tag() == TYPE_INTERVAL ) + return make_intrusive(- v->InternalDouble()); else - return zeek::val_mgr->Int(- v->CoerceToInt()); + return val_mgr->Int(- v->CoerceToInt()); } SizeExpr::SizeExpr(ExprPtr arg_op) @@ -1162,10 +1162,10 @@ SizeExpr::SizeExpr(ExprPtr arg_op) if ( IsError() ) return; - if ( op->GetType()->InternalType() == zeek::TYPE_INTERNAL_DOUBLE ) - SetType(base_type(zeek::TYPE_DOUBLE)); + if ( op->GetType()->InternalType() == TYPE_INTERNAL_DOUBLE ) + SetType(base_type(TYPE_DOUBLE)); else - SetType(base_type(zeek::TYPE_COUNT)); + SetType(base_type(TYPE_COUNT)); } ValPtr SizeExpr::Eval(Frame* f) const @@ -1199,11 +1199,11 @@ AddExpr::AddExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsVector(bt2) ) bt2 = op2->GetType()->AsVectorType()->Yield()->Tag(); - zeek::TypePtr base_result_type; + TypePtr base_result_type; - if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) ) + if ( bt2 == TYPE_INTERVAL && ( bt1 == TYPE_TIME || bt1 == TYPE_INTERVAL ) ) base_result_type = base_type(bt1); - else if ( bt2 == zeek::TYPE_TIME && bt1 == zeek::TYPE_INTERVAL ) + else if ( bt2 == TYPE_TIME && bt1 == TYPE_INTERVAL ) base_result_type = base_type(bt2); else if ( BothArithmetic(bt1, bt2) ) PromoteType(max_type(bt1, bt2), is_vector(op1) || is_vector(op2)); @@ -1215,7 +1215,7 @@ AddExpr::AddExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( base_result_type ) { if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(std::move(base_result_type))); + SetType(make_intrusive(std::move(base_result_type))); else SetType(std::move(base_result_type)); } @@ -1224,8 +1224,8 @@ AddExpr::AddExpr(ExprPtr arg_op1, ExprPtr arg_op2) void AddExpr::Canonicize() { if ( expr_greater(op2.get(), op1.get()) || - (op1->GetType()->Tag() == zeek::TYPE_INTERVAL && - op2->GetType()->Tag() == zeek::TYPE_TIME) || + (op1->GetType()->Tag() == TYPE_INTERVAL && + op2->GetType()->Tag() == TYPE_TIME) || (op2->IsConst() && ! is_vector(op2->ExprVal()) && ! op1->IsConst())) SwapOps(); } @@ -1255,7 +1255,7 @@ AddToExpr::AddToExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsArithmetic(bt2) ) { if ( bt2 != bt1 ) - op2 = zeek::make_intrusive(std::move(op2), bt1); + op2 = make_intrusive(std::move(op2), bt1); SetType(op1->GetType()); } @@ -1264,8 +1264,8 @@ AddToExpr::AddToExpr(ExprPtr arg_op1, ExprPtr arg_op2) ExprError("appending non-arithmetic to arithmetic vector"); } - else if ( bt1 != bt2 && bt1 != zeek::TYPE_ANY ) - ExprError(zeek::util::fmt("incompatible vector append: %s and %s", + else if ( bt1 != bt2 && bt1 != TYPE_ANY ) + ExprError(util::fmt("incompatible vector append: %s and %s", type_name(bt1), type_name(bt2))); else @@ -1324,13 +1324,13 @@ SubExpr::SubExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsVector(bt2) ) bt2 = t2->AsVectorType()->Yield()->Tag(); - zeek::TypePtr base_result_type; + TypePtr base_result_type; - if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) ) + if ( bt2 == TYPE_INTERVAL && ( bt1 == TYPE_TIME || bt1 == TYPE_INTERVAL ) ) base_result_type = base_type(bt1); - else if ( bt1 == zeek::TYPE_TIME && bt2 == zeek::TYPE_TIME ) - SetType(base_type(zeek::TYPE_INTERVAL)); + else if ( bt1 == TYPE_TIME && bt2 == TYPE_TIME ) + SetType(base_type(TYPE_INTERVAL)); else if ( t1->IsSet() && t2->IsSet() ) { @@ -1349,7 +1349,7 @@ SubExpr::SubExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( base_result_type ) { if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(std::move(base_result_type))); + SetType(make_intrusive(std::move(base_result_type))); else SetType(std::move(base_result_type)); } @@ -1411,10 +1411,10 @@ TimesExpr::TimesExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsVector(bt2) ) bt2 = op2->GetType()->AsVectorType()->Yield()->Tag(); - if ( bt1 == zeek::TYPE_INTERVAL || bt2 == zeek::TYPE_INTERVAL ) + if ( bt1 == TYPE_INTERVAL || bt2 == TYPE_INTERVAL ) { if ( IsArithmetic(bt1) || IsArithmetic(bt2) ) - PromoteType(zeek::TYPE_INTERVAL, is_vector(op1) || is_vector(op2) ); + PromoteType(TYPE_INTERVAL, is_vector(op1) || is_vector(op2) ); else ExprError("multiplication with interval requires arithmetic operand"); } @@ -1426,7 +1426,7 @@ TimesExpr::TimesExpr(ExprPtr arg_op1, ExprPtr arg_op2) void TimesExpr::Canonicize() { - if ( expr_greater(op2.get(), op1.get()) || op2->GetType()->Tag() == zeek::TYPE_INTERVAL || + if ( expr_greater(op2.get(), op1.get()) || op2->GetType()->Tag() == TYPE_INTERVAL || (op2->IsConst() && ! is_vector(op2->ExprVal()) && ! op1->IsConst()) ) SwapOps(); } @@ -1447,16 +1447,16 @@ DivideExpr::DivideExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsVector(bt2) ) bt2 = op2->GetType()->AsVectorType()->Yield()->Tag(); - if ( bt1 == zeek::TYPE_INTERVAL || bt2 == zeek::TYPE_INTERVAL ) + if ( bt1 == TYPE_INTERVAL || bt2 == TYPE_INTERVAL ) { if ( IsArithmetic(bt1) || IsArithmetic(bt2) ) - PromoteType(zeek::TYPE_INTERVAL, is_vector(op1) || is_vector(op2)); - else if ( bt1 == zeek::TYPE_INTERVAL && bt2 == zeek::TYPE_INTERVAL ) + PromoteType(TYPE_INTERVAL, is_vector(op1) || is_vector(op2)); + else if ( bt1 == TYPE_INTERVAL && bt2 == TYPE_INTERVAL ) { if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(base_type(zeek::TYPE_DOUBLE))); + SetType(make_intrusive(base_type(TYPE_DOUBLE))); else - SetType(base_type(zeek::TYPE_DOUBLE)); + SetType(base_type(TYPE_DOUBLE)); } else ExprError("division of interval requires arithmetic operand"); @@ -1465,9 +1465,9 @@ DivideExpr::DivideExpr(ExprPtr arg_op1, ExprPtr arg_op2) else if ( BothArithmetic(bt1, bt2) ) PromoteType(max_type(bt1, bt2), is_vector(op1) || is_vector(op2)); - else if ( bt1 == zeek::TYPE_ADDR && ! is_vector(op2) && - (bt2 == zeek::TYPE_COUNT || bt2 == zeek::TYPE_INT) ) - SetType(base_type(zeek::TYPE_SUBNET)); + else if ( bt1 == TYPE_ADDR && ! is_vector(op2) && + (bt2 == TYPE_COUNT || bt2 == TYPE_INT) ) + SetType(base_type(TYPE_SUBNET)); else ExprError("requires arithmetic operands"); @@ -1477,7 +1477,7 @@ ValPtr DivideExpr::AddrFold(Val* v1, Val* v2) const { uint32_t mask; - if ( v2->GetType()->Tag() == zeek::TYPE_COUNT ) + if ( v2->GetType()->Tag() == TYPE_COUNT ) mask = static_cast(v2->InternalUnsigned()); else mask = static_cast(v2->InternalInt()); @@ -1487,15 +1487,15 @@ ValPtr DivideExpr::AddrFold(Val* v1, Val* v2) const if ( a.GetFamily() == IPv4 ) { if ( mask > 32 ) - RuntimeError(zeek::util::fmt("bad IPv4 subnet prefix length: %" PRIu32, mask)); + RuntimeError(util::fmt("bad IPv4 subnet prefix length: %" PRIu32, mask)); } else { if ( mask > 128 ) - RuntimeError(zeek::util::fmt("bad IPv6 subnet prefix length: %" PRIu32, mask)); + RuntimeError(util::fmt("bad IPv6 subnet prefix length: %" PRIu32, mask)); } - return zeek::make_intrusive(a, mask); + return make_intrusive(a, mask); } ModExpr::ModExpr(ExprPtr arg_op1, ExprPtr arg_op2) @@ -1541,11 +1541,11 @@ BoolExpr::BoolExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) if ( is_vector(op1) || is_vector(op2) ) { if ( ! (is_vector(op1) && is_vector(op2)) ) - zeek::reporter->Warning("mixing vector and scalar operands is deprecated"); - SetType(zeek::make_intrusive(base_type(zeek::TYPE_BOOL))); + reporter->Warning("mixing vector and scalar operands is deprecated"); + SetType(make_intrusive(base_type(TYPE_BOOL))); } else - SetType(base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } else ExprError("requires boolean operands"); @@ -1601,12 +1601,12 @@ ValPtr BoolExpr::Eval(Frame* f) const if ( is_vec1 ) { scalar_v = op2->Eval(f); - vector_v = {zeek::AdoptRef{}, v1.release()->AsVectorVal()}; + vector_v = {AdoptRef{}, v1.release()->AsVectorVal()}; } else { scalar_v = std::move(v1); - vector_v = {zeek::AdoptRef{}, op2->Eval(f).release()->AsVectorVal()}; + vector_v = {AdoptRef{}, op2->Eval(f).release()->AsVectorVal()}; } if ( ! scalar_v || ! vector_v ) @@ -1619,7 +1619,7 @@ ValPtr BoolExpr::Eval(Frame* f) const if ( scalar_v->IsZero() == is_and ) { - result = zeek::make_intrusive(GetType()); + result = make_intrusive(GetType()); result->Resize(vector_v->Size()); result->AssignRepeat(0, result->Size(), std::move(scalar_v)); } @@ -1644,7 +1644,7 @@ ValPtr BoolExpr::Eval(Frame* f) const return nullptr; } - auto result = zeek::make_intrusive(GetType()); + auto result = make_intrusive(GetType()); result->Resize(vec_v1->Size()); for ( unsigned int i = 0; i < vec_v1->Size(); ++i ) @@ -1657,7 +1657,7 @@ ValPtr BoolExpr::Eval(Frame* f) const (! op1->IsZero() && ! op2->IsZero()) : (! op1->IsZero() || ! op2->IsZero()); - result->Assign(i, zeek::val_mgr->Bool(local_result)); + result->Assign(i, val_mgr->Bool(local_result)); } else result->Assign(i, nullptr); @@ -1685,22 +1685,22 @@ BitExpr::BitExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) if ( IsVector(bt2) ) bt2 = t2->AsVectorType()->Yield()->Tag(); - if ( (bt1 == zeek::TYPE_COUNT) && (bt2 == zeek::TYPE_COUNT) ) + if ( (bt1 == TYPE_COUNT) && (bt2 == TYPE_COUNT) ) { if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(base_type(zeek::TYPE_COUNT))); + SetType(make_intrusive(base_type(TYPE_COUNT))); else - SetType(base_type(zeek::TYPE_COUNT)); + SetType(base_type(TYPE_COUNT)); } - else if ( bt1 == zeek::TYPE_PATTERN ) + else if ( bt1 == TYPE_PATTERN ) { - if ( bt2 != zeek::TYPE_PATTERN ) + if ( bt2 != TYPE_PATTERN ) ExprError("cannot mix pattern and non-pattern operands"); else if ( tag == EXPR_XOR ) ExprError("'^' operator does not apply to patterns"); else - SetType(base_type(zeek::TYPE_PATTERN)); + SetType(base_type(TYPE_PATTERN)); } else if ( t1->IsSet() && t2->IsSet() ) @@ -1735,39 +1735,39 @@ EqExpr::EqExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) bt2 = t2->AsVectorType()->Yield()->Tag(); if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(base_type(zeek::TYPE_BOOL))); + SetType(make_intrusive(base_type(TYPE_BOOL))); else - SetType(base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); if ( BothArithmetic(bt1, bt2) ) PromoteOps(max_type(bt1, bt2)); else if ( EitherArithmetic(bt1, bt2) && // Allow comparisons with zero. - ((bt1 == zeek::TYPE_TIME && op2->IsZero()) || - (bt2 == zeek::TYPE_TIME && op1->IsZero())) ) - PromoteOps(zeek::TYPE_TIME); + ((bt1 == TYPE_TIME && op2->IsZero()) || + (bt2 == TYPE_TIME && op1->IsZero())) ) + PromoteOps(TYPE_TIME); else if ( bt1 == bt2 ) { switch ( bt1 ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: - case zeek::TYPE_STRING: - case zeek::TYPE_PORT: - case zeek::TYPE_ADDR: - case zeek::TYPE_SUBNET: - case zeek::TYPE_ERROR: - case zeek::TYPE_FUNC: + case TYPE_BOOL: + case TYPE_TIME: + case TYPE_INTERVAL: + case TYPE_STRING: + case TYPE_PORT: + case TYPE_ADDR: + case TYPE_SUBNET: + case TYPE_ERROR: + case TYPE_FUNC: break; - case zeek::TYPE_ENUM: + case TYPE_ENUM: if ( ! same_type(t1, t2) ) ExprError("illegal enum comparison"); break; - case zeek::TYPE_TABLE: + case TYPE_TABLE: if ( t1->IsSet() && t2->IsSet() ) { if ( ! same_type(t1, t2) ) @@ -1782,7 +1782,7 @@ EqExpr::EqExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) } } - else if ( bt1 == zeek::TYPE_PATTERN && bt2 == zeek::TYPE_STRING ) + else if ( bt1 == TYPE_PATTERN && bt2 == TYPE_STRING ) ; else @@ -1791,10 +1791,10 @@ EqExpr::EqExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) void EqExpr::Canonicize() { - if ( op2->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( op2->GetType()->Tag() == TYPE_PATTERN ) SwapOps(); - else if ( op1->GetType()->Tag() == zeek::TYPE_PATTERN ) + else if ( op1->GetType()->Tag() == TYPE_PATTERN ) ; else if ( expr_greater(op2.get(), op1.get()) ) @@ -1803,16 +1803,16 @@ void EqExpr::Canonicize() ValPtr EqExpr::Fold(Val* v1, Val* v2) const { - if ( op1->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( op1->GetType()->Tag() == TYPE_PATTERN ) { RE_Matcher* re = v1->AsPattern(); const String* s = v2->AsString(); if ( tag == EXPR_EQ ) - return zeek::val_mgr->Bool(re->MatchExactly(s)); + return val_mgr->Bool(re->MatchExactly(s)); else - return zeek::val_mgr->Bool(! re->MatchExactly(s)); + return val_mgr->Bool(! re->MatchExactly(s)); } - else if ( op1->GetType()->Tag() == zeek::TYPE_FUNC ) + else if ( op1->GetType()->Tag() == TYPE_FUNC ) { auto res = v1->AsFunc() == v2->AsFunc(); return val_mgr->Bool(tag == EXPR_EQ ? res : ! res); @@ -1842,9 +1842,9 @@ RelExpr::RelExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) bt2 = t2->AsVectorType()->Yield()->Tag(); if ( is_vector(op1) || is_vector(op2) ) - SetType(zeek::make_intrusive(base_type(zeek::TYPE_BOOL))); + SetType(make_intrusive(base_type(TYPE_BOOL))); else - SetType(base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); if ( BothArithmetic(bt1, bt2) ) PromoteOps(max_type(bt1, bt2)); @@ -1858,9 +1858,9 @@ RelExpr::RelExpr(BroExprTag arg_tag, ExprPtr arg_op1, ExprPtr arg_op2) else if ( bt1 != bt2 ) ExprError("operands must be of the same type"); - else if ( bt1 != zeek::TYPE_TIME && bt1 != zeek::TYPE_INTERVAL && - bt1 != zeek::TYPE_PORT && bt1 != zeek::TYPE_ADDR && - bt1 != zeek::TYPE_STRING ) + else if ( bt1 != TYPE_TIME && bt1 != TYPE_INTERVAL && + bt1 != TYPE_PORT && bt1 != TYPE_ADDR && + bt1 != TYPE_STRING ) ExprError("illegal comparison"); } @@ -1891,7 +1891,7 @@ CondExpr::CondExpr(ExprPtr arg_op1, ExprPtr arg_op2, ExprPtr arg_op3) if ( op1->IsError() || op2->IsError() || op3->IsError() ) SetError(); - else if ( bt1 != zeek::TYPE_BOOL ) + else if ( bt1 != TYPE_BOOL ) ExprError("requires boolean conditional"); else @@ -1916,12 +1916,12 @@ CondExpr::CondExpr(ExprPtr arg_op1, ExprPtr arg_op2, ExprPtr arg_op3) { TypeTag t = max_type(bt2, bt3); if ( bt2 != t ) - op2 = zeek::make_intrusive(std::move(op2), t); + op2 = make_intrusive(std::move(op2), t); if ( bt3 != t ) - op3 = zeek::make_intrusive(std::move(op3), t); + op3 = make_intrusive(std::move(op3), t); if ( is_vector(op2) ) - SetType(zeek::make_intrusive(base_type(t))); + SetType(make_intrusive(base_type(t))); else SetType(base_type(t)); } @@ -1975,7 +1975,7 @@ ValPtr CondExpr::Eval(Frame* f) const return nullptr; } - auto result = zeek::make_intrusive(GetType()); + auto result = make_intrusive(GetType()); result->Resize(cond->Size()); for ( unsigned int i = 0; i < cond->Size(); ++i ) @@ -2032,7 +2032,7 @@ RefExpr::RefExpr(ExprPtr arg_op) if ( IsError() ) return; - if ( ! zeek::is_assignable(op->GetType()->Tag()) ) + if ( ! is_assignable(op->GetType()->Tag()) ) ExprError("illegal assignment target"); else SetType(op->GetType()); @@ -2040,7 +2040,7 @@ RefExpr::RefExpr(ExprPtr arg_op) ExprPtr RefExpr::MakeLvalue() { - return {zeek::NewRef{}, this}; + return {NewRef{}, this}; } void RefExpr::Assign(Frame* f, ValPtr v) @@ -2088,13 +2088,13 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) TypeTag bt1 = op1->GetType()->Tag(); TypeTag bt2 = op2->GetType()->Tag(); - if ( bt1 == zeek::TYPE_LIST && bt2 == zeek::TYPE_ANY ) + if ( bt1 == TYPE_LIST && bt2 == TYPE_ANY ) // This is ok because we cannot explicitly declare lists on // the script level. return true; // This should be one of them, but not both (i.e. XOR) - if ( ((bt1 == zeek::TYPE_ENUM) ^ (bt2 == zeek::TYPE_ENUM)) ) + if ( ((bt1 == TYPE_ENUM) ^ (bt2 == TYPE_ENUM)) ) { ExprError("can't convert to/from enumerated type"); return false; @@ -2103,20 +2103,20 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) if ( IsArithmetic(bt1) ) return TypeCheckArithmetics(bt1, bt2); - if ( bt1 == zeek::TYPE_TIME && IsArithmetic(bt2) && op2->IsZero() ) + if ( bt1 == TYPE_TIME && IsArithmetic(bt2) && op2->IsZero() ) { // Allow assignments to zero as a special case. - op2 = zeek::make_intrusive(std::move(op2), bt1); + op2 = make_intrusive(std::move(op2), bt1); return true; } - if ( bt1 == zeek::TYPE_TABLE && bt2 == bt1 && + if ( bt1 == TYPE_TABLE && bt2 == bt1 && op2->GetType()->AsTableType()->IsUnspecifiedTable() ) { - op2 = zeek::make_intrusive(std::move(op2), op1->GetType()); + op2 = make_intrusive(std::move(op2), op1->GetType()); return true; } - if ( bt1 == zeek::TYPE_TABLE && op2->Tag() == EXPR_LIST ) + if ( bt1 == TYPE_TABLE && op2->Tag() == EXPR_LIST ) { std::unique_ptr> attr_copy; @@ -2126,11 +2126,11 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) bool empty_list_assignment = (op2->AsListExpr()->Exprs().empty()); if ( op1->GetType()->IsSet() ) - op2 = zeek::make_intrusive( - zeek::cast_intrusive(op2), std::move(attr_copy)); + op2 = make_intrusive( + cast_intrusive(op2), std::move(attr_copy)); else - op2 = zeek::make_intrusive( - zeek::cast_intrusive(op2), std::move(attr_copy)); + op2 = make_intrusive( + cast_intrusive(op2), std::move(attr_copy)); if ( ! empty_list_assignment && ! same_type(op1->GetType(), op2->GetType()) ) { @@ -2145,25 +2145,25 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) return true; } - if ( bt1 == zeek::TYPE_VECTOR ) + if ( bt1 == TYPE_VECTOR ) { if ( bt2 == bt1 && op2->GetType()->AsVectorType()->IsUnspecifiedVector() ) { - op2 = zeek::make_intrusive(std::move(op2), op1->GetType()); + op2 = make_intrusive(std::move(op2), op1->GetType()); return true; } if ( op2->Tag() == EXPR_LIST ) { - op2 = zeek::make_intrusive( - IntrusivePtr{zeek::AdoptRef{}, op2.release()->AsListExpr()}, + op2 = make_intrusive( + IntrusivePtr{AdoptRef{}, op2.release()->AsListExpr()}, op1->GetType()); return true; } } - if ( op1->GetType()->Tag() == zeek::TYPE_RECORD && - op2->GetType()->Tag() == zeek::TYPE_RECORD ) + if ( op1->GetType()->Tag() == TYPE_RECORD && + op2->GetType()->Tag() == TYPE_RECORD ) { if ( same_type(op1->GetType(), op2->GetType()) ) { @@ -2183,13 +2183,13 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) } // Need to coerce. - op2 = zeek::make_intrusive(std::move(op2), op1->GetType()); + op2 = make_intrusive(std::move(op2), op1->GetType()); return true; } if ( ! same_type(op1->GetType(), op2->GetType()) ) { - if ( bt1 == zeek::TYPE_TABLE && bt2 == zeek::TYPE_TABLE ) + if ( bt1 == TYPE_TABLE && bt2 == TYPE_TABLE ) { if ( op2->Tag() == EXPR_SET_CONSTRUCTOR ) { @@ -2221,12 +2221,12 @@ bool AssignExpr::TypeCheck(const AttributesPtr& attrs) attr_copy = std::make_unique>(a); } - int errors_before = zeek::reporter->Errors(); - op2 = zeek::make_intrusive( - IntrusivePtr{zeek::NewRef{}, ctor_list}, + int errors_before = reporter->Errors(); + op2 = make_intrusive( + IntrusivePtr{NewRef{}, ctor_list}, std::move(attr_copy), op1->GetType()); - int errors_after = zeek::reporter->Errors(); + int errors_after = reporter->Errors(); if ( errors_after > errors_before ) { @@ -2249,32 +2249,32 @@ bool AssignExpr::TypeCheckArithmetics(TypeTag bt1, TypeTag bt2) { if ( ! IsArithmetic(bt2) ) { - ExprError(zeek::util::fmt("assignment of non-arithmetic value to arithmetic (%s/%s)", + ExprError(util::fmt("assignment of non-arithmetic value to arithmetic (%s/%s)", type_name(bt1), type_name(bt2))); return false; } - if ( bt1 == zeek::TYPE_DOUBLE ) + if ( bt1 == TYPE_DOUBLE ) { - PromoteOps(zeek::TYPE_DOUBLE); + PromoteOps(TYPE_DOUBLE); return true; } - if ( bt2 == zeek::TYPE_DOUBLE ) + if ( bt2 == TYPE_DOUBLE ) { Warn("dangerous assignment of double to integral"); - op2 = zeek::make_intrusive(std::move(op2), bt1); + op2 = make_intrusive(std::move(op2), bt1); bt2 = op2->GetType()->Tag(); } - if ( bt1 == zeek::TYPE_INT ) - PromoteOps(zeek::TYPE_INT); + if ( bt1 == TYPE_INT ) + PromoteOps(TYPE_INT); else { - if ( bt2 == zeek::TYPE_INT ) + if ( bt2 == TYPE_INT ) { Warn("dangerous assignment of integer to count"); - op2 = zeek::make_intrusive(std::move(op2), bt1); + op2 = make_intrusive(std::move(op2), bt1); } // Assignment of count to counter or vice @@ -2307,7 +2307,7 @@ ValPtr AssignExpr::Eval(Frame* f) const return nullptr; } -zeek::TypePtr AssignExpr::InitType() const +TypePtr AssignExpr::InitType() const { if ( op1->Tag() != EXPR_LIST ) { @@ -2316,11 +2316,11 @@ zeek::TypePtr AssignExpr::InitType() const } const auto& tl = op1->GetType(); - if ( tl->Tag() != zeek::TYPE_LIST ) + if ( tl->Tag() != TYPE_LIST ) Internal("inconsistent list expr in AssignExpr::InitType"); - return zeek::make_intrusive( - IntrusivePtr{zeek::NewRef{}, tl->AsTypeList()}, + return make_intrusive( + IntrusivePtr{NewRef{}, tl->AsTypeList()}, op2->GetType()); } @@ -2333,7 +2333,7 @@ void AssignExpr::EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) con if ( IsRecordElement(&td) ) { - if ( t->Tag() != zeek::TYPE_RECORD ) + if ( t->Tag() != TYPE_RECORD ) { RuntimeError("not a record initializer"); return; @@ -2388,7 +2388,7 @@ ValPtr AssignExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( IsRecordElement(&td) ) { - if ( t->Tag() != zeek::TYPE_RECORD ) + if ( t->Tag() != TYPE_RECORD ) { Error("not a record initializer", t); return nullptr; @@ -2403,7 +2403,7 @@ ValPtr AssignExpr::InitVal(const zeek::Type* t, ValPtr aggr) const return nullptr; } - if ( aggr->GetType()->Tag() != zeek::TYPE_RECORD ) + if ( aggr->GetType()->Tag() != TYPE_RECORD ) Internal("bad aggregate in AssignExpr::InitVal"); RecordVal* aggr_r = aggr->AsRecordVal(); @@ -2419,16 +2419,16 @@ ValPtr AssignExpr::InitVal(const zeek::Type* t, ValPtr aggr) const else if ( op1->Tag() == EXPR_LIST ) { - if ( t->Tag() != zeek::TYPE_TABLE ) + if ( t->Tag() != TYPE_TABLE ) { Error("not a table initialization", t); return nullptr; } - if ( aggr->GetType()->Tag() != zeek::TYPE_TABLE ) + if ( aggr->GetType()->Tag() != TYPE_TABLE ) Internal("bad aggregate in AssignExpr::InitVal"); - auto tv = zeek::cast_intrusive(std::move(aggr)); + auto tv = cast_intrusive(std::move(aggr)); const TableType* tt = tv->GetType()->AsTableType(); const auto& yt = tv->GetType()->Yield(); @@ -2459,7 +2459,7 @@ bool AssignExpr::IsRecordElement(TypeDecl* td) const { const NameExpr* n = (const NameExpr*) op1.get(); td->type = op2->GetType(); - td->id = zeek::util::copy_string(n->Id()->Name()); + td->id = util::copy_string(n->Id()->Name()); } return true; @@ -2519,7 +2519,7 @@ IndexExpr::IndexExpr(ExprPtr arg_op1, ListExprPtr arg_op2, bool arg_is_slice) if ( match_type == DOES_NOT_MATCH_INDEX ) { std::string error_msg = - zeek::util::fmt("expression with type '%s' is not a type that can be indexed", + util::fmt("expression with type '%s' is not a type that can be indexed", type_name(op1->GetType()->Tag())); SetError(error_msg.data()); } @@ -2527,20 +2527,20 @@ IndexExpr::IndexExpr(ExprPtr arg_op1, ListExprPtr arg_op2, bool arg_is_slice) else if ( ! op1->GetType()->Yield() ) { if ( IsString(op1->GetType()->Tag()) && match_type == MATCHES_INDEX_SCALAR ) - SetType(base_type(zeek::TYPE_STRING)); + SetType(base_type(TYPE_STRING)); else // It's a set - so indexing it yields void. We don't // directly generate an error message, though, since this // expression might be part of an add/delete statement, // rather than yielding a value. - SetType(base_type(zeek::TYPE_VOID)); + SetType(base_type(TYPE_VOID)); } else if ( match_type == MATCHES_INDEX_SCALAR ) SetType(op1->GetType()->Yield()); else if ( match_type == MATCHES_INDEX_VECTOR ) - SetType(zeek::make_intrusive(op1->GetType()->Yield())); + SetType(make_intrusive(op1->GetType()->Yield())); else ExprError("Unknown MatchesIndex() return value"); @@ -2560,7 +2560,7 @@ bool IndexExpr::CanDel() const if ( IsError() ) return true; // avoid cascading the error report - return op1->GetType()->Tag() == zeek::TYPE_TABLE; + return op1->GetType()->Tag() == TYPE_TABLE; } void IndexExpr::Add(Frame* f) @@ -2604,7 +2604,7 @@ ExprPtr IndexExpr::MakeLvalue() if ( IsString(op1->GetType()->Tag()) ) ExprError("cannot assign to string index expression"); - return zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, this}); + return make_intrusive(IntrusivePtr{NewRef{}, this}); } ValPtr IndexExpr::Eval(Frame* f) const @@ -2625,7 +2625,7 @@ ValPtr IndexExpr::Eval(Frame* f) const { VectorVal* v_v1 = v1->AsVectorVal(); VectorVal* v_v2 = indv->AsVectorVal(); - auto v_result = zeek::make_intrusive(GetType()); + auto v_result = make_intrusive(GetType()); // Booleans select each element (or not). if ( IsBool(v_v2->GetType()->Yield()->Tag()) ) @@ -2676,7 +2676,7 @@ ValPtr IndexExpr::Fold(Val* v1, Val* v2) const ValPtr v; switch ( v1->GetType()->Tag() ) { - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { VectorVal* vect = v1->AsVectorVal(); const ListVal* lv = v2->AsListVal(); @@ -2686,7 +2686,7 @@ ValPtr IndexExpr::Fold(Val* v1, Val* v2) const else { size_t len = vect->Size(); - auto result = zeek::make_intrusive(vect->GetType()); + auto result = make_intrusive(vect->GetType()); bro_int_t first = get_slice_index(lv->Idx(0)->CoerceToInt(), len); bro_int_t last = get_slice_index(lv->Idx(1)->CoerceToInt(), len); @@ -2705,11 +2705,11 @@ ValPtr IndexExpr::Fold(Val* v1, Val* v2) const } break; - case zeek::TYPE_TABLE: - v = v1->AsTableVal()->FindOrDefault({zeek::NewRef{}, v2}); // Then, we jump into the TableVal here. + case TYPE_TABLE: + v = v1->AsTableVal()->FindOrDefault({NewRef{}, v2}); // Then, we jump into the TableVal here. break; - case zeek::TYPE_STRING: + case TYPE_STRING: { const ListVal* lv = v2->AsListVal(); const String* s = v1->AsString(); @@ -2738,7 +2738,7 @@ ValPtr IndexExpr::Fold(Val* v1, Val* v2) const substring = s->GetSubstring(first, substring_len); } - return zeek::make_intrusive(substring ? substring : new String("")); + return make_intrusive(substring ? substring : new String("")); } default: @@ -2774,7 +2774,7 @@ void IndexExpr::Assign(Frame* f, ValPtr v) auto v_extra = v; switch ( v1->GetType()->Tag() ) { - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { const ListVal* lv = v2->AsListVal(); VectorVal* v1_vect = v1->AsVectorVal(); @@ -2805,8 +2805,8 @@ void IndexExpr::Assign(Frame* f, ValPtr v) v->Describe(&d); const auto& vt = v->GetType(); auto vtt = vt->Tag(); - std::string tn = vtt == zeek::TYPE_RECORD ? vt->GetName() : type_name(vtt); - RuntimeErrorWithCallStack(zeek::util::fmt( + std::string tn = vtt == TYPE_RECORD ? vt->GetName() : type_name(vtt); + RuntimeErrorWithCallStack(util::fmt( "vector index assignment failed for invalid type '%s', value: %s", tn.data(), d.Description())); } @@ -2816,7 +2816,7 @@ void IndexExpr::Assign(Frame* f, ValPtr v) break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: if ( ! v1->AsTableVal()->Assign(std::move(v2), std::move(v)) ) { v = std::move(v_extra); @@ -2827,8 +2827,8 @@ void IndexExpr::Assign(Frame* f, ValPtr v) v->Describe(&d); const auto& vt = v->GetType(); auto vtt = vt->Tag(); - std::string tn = vtt == zeek::TYPE_RECORD ? vt->GetName() : type_name(vtt); - RuntimeErrorWithCallStack(zeek::util::fmt( + std::string tn = vtt == TYPE_RECORD ? vt->GetName() : type_name(vtt); + RuntimeErrorWithCallStack(util::fmt( "table index assignment failed for invalid type '%s', value: %s", tn.data(), d.Description())); } @@ -2837,7 +2837,7 @@ void IndexExpr::Assign(Frame* f, ValPtr v) } break; - case zeek::TYPE_STRING: + case TYPE_STRING: RuntimeErrorWithCallStack("assignment via string index accessor not allowed"); break; @@ -2875,7 +2875,7 @@ TraversalCode IndexExpr::Traverse(TraversalCallback* cb) const FieldExpr::FieldExpr(ExprPtr arg_op, const char* arg_field_name) : UnaryExpr(EXPR_FIELD, std::move(arg_op)), - field_name(zeek::util::copy_string(arg_field_name)), td(nullptr), field(0) + field_name(util::copy_string(arg_field_name)), td(nullptr), field(0) { if ( IsError() ) return; @@ -2895,7 +2895,7 @@ FieldExpr::FieldExpr(ExprPtr arg_op, const char* arg_field_name) td = rt->FieldDecl(field); if ( rt->IsFieldDeprecated(field) ) - zeek::reporter->Warning("%s", rt->GetFieldDeprecationWarning(field, false).c_str()); + reporter->Warning("%s", rt->GetFieldDeprecationWarning(field, false).c_str()); } } } @@ -2907,7 +2907,7 @@ FieldExpr::~FieldExpr() ExprPtr FieldExpr::MakeLvalue() { - return zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, this}); + return make_intrusive(IntrusivePtr{NewRef{}, this}); } bool FieldExpr::CanDel() const @@ -2981,9 +2981,9 @@ HasFieldExpr::HasFieldExpr(ExprPtr arg_op, const char* arg_field_name) if ( field < 0 ) ExprError("no such field in record"); else if ( rt->IsFieldDeprecated(field) ) - zeek::reporter->Warning("%s", rt->GetFieldDeprecationWarning(field, true).c_str()); + reporter->Warning("%s", rt->GetFieldDeprecationWarning(field, true).c_str()); - SetType(base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } } @@ -2995,7 +2995,7 @@ HasFieldExpr::~HasFieldExpr() ValPtr HasFieldExpr::Fold(Val* v) const { auto rv = v->AsRecordVal(); - return zeek::val_mgr->Bool(rv->GetField(field) != nullptr); + return val_mgr->Bool(rv->GetField(field) != nullptr); } void HasFieldExpr::ExprDescribe(ODesc* d) const @@ -3036,11 +3036,11 @@ RecordConstructorExpr::RecordConstructorExpr(ListExprPtr constructor_list) FieldAssignExpr* field = (FieldAssignExpr*) e; const auto& field_type = field->GetType(); - char* field_name = zeek::util::copy_string(field->FieldName()); + char* field_name = util::copy_string(field->FieldName()); record_types->push_back(new TypeDecl(field_name, field_type)); } - SetType(zeek::make_intrusive(record_types)); + SetType(make_intrusive(record_types)); } RecordConstructorExpr::~RecordConstructorExpr() @@ -3055,8 +3055,8 @@ ValPtr RecordConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const { RecordVal* rv = v->AsRecordVal(); auto bt = const_cast(t); - RecordTypePtr rt{zeek::NewRef{}, bt->AsRecordType()}; - auto aggr_rec = zeek::cast_intrusive(std::move(aggr)); + RecordTypePtr rt{NewRef{}, bt->AsRecordType()}; + auto aggr_rec = cast_intrusive(std::move(aggr)); auto ar = rv->CoerceTo(std::move(rt), std::move(aggr_rec)); if ( ar ) @@ -3070,12 +3070,12 @@ ValPtr RecordConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const ValPtr RecordConstructorExpr::Fold(Val* v) const { ListVal* lv = v->AsListVal(); - auto rt = zeek::cast_intrusive(type); + auto rt = cast_intrusive(type); if ( lv->Length() != rt->NumFields() ) RuntimeErrorWithCallStack("inconsistency evaluating record constructor"); - auto rv = zeek::make_intrusive(std::move(rt)); + auto rv = make_intrusive(std::move(rt)); for ( int i = 0; i < lv->Length(); ++i ) rv->Assign(i, lv->Idx(i)); @@ -3092,7 +3092,7 @@ void RecordConstructorExpr::ExprDescribe(ODesc* d) const TableConstructorExpr::TableConstructorExpr(ListExprPtr constructor_list, std::unique_ptr> arg_attrs, - zeek::TypePtr arg_type) + TypePtr arg_type) : UnaryExpr(EXPR_TABLE_CONSTRUCTOR, std::move(constructor_list)) { if ( IsError() ) @@ -3112,7 +3112,7 @@ TableConstructorExpr::TableConstructorExpr(ListExprPtr constructor_list, else { if ( op->AsListExpr()->Exprs().empty() ) - SetType(zeek::make_intrusive(zeek::make_intrusive(base_type(zeek::TYPE_ANY)), nullptr)); + SetType(make_intrusive(make_intrusive(base_type(TYPE_ANY)), nullptr)); else { SetType(init_type(op.get())); @@ -3120,14 +3120,14 @@ TableConstructorExpr::TableConstructorExpr(ListExprPtr constructor_list, if ( ! type ) SetError(); - else if ( type->Tag() != zeek::TYPE_TABLE || + else if ( type->Tag() != TYPE_TABLE || type->AsTableType()->IsSet() ) SetError("values in table(...) constructor do not specify a table"); } } if ( arg_attrs ) - attrs = zeek::make_intrusive(std::move(*arg_attrs), type, false, false); + attrs = make_intrusive(std::move(*arg_attrs), type, false, false); const auto& indices = type->AsTableType()->GetIndices()->GetTypes(); const ExprPList& cle = op->AsListExpr()->Exprs(); @@ -3175,7 +3175,7 @@ ValPtr TableConstructorExpr::Eval(Frame* f) const if ( IsError() ) return nullptr; - auto aggr = zeek::make_intrusive(GetType(), attrs); + auto aggr = make_intrusive(GetType(), attrs); const ExprPList& exprs = op->AsListExpr()->Exprs(); for ( const auto& expr : exprs ) @@ -3194,8 +3194,8 @@ ValPtr TableConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const auto tt = GetType(); auto tval = aggr ? - TableValPtr{zeek::AdoptRef{}, aggr.release()->AsTableVal()} : - zeek::make_intrusive(std::move(tt), attrs); + TableValPtr{AdoptRef{}, aggr.release()->AsTableVal()} : + make_intrusive(std::move(tt), attrs); const ExprPList& exprs = op->AsListExpr()->Exprs(); for ( const auto& expr : exprs ) @@ -3213,7 +3213,7 @@ void TableConstructorExpr::ExprDescribe(ODesc* d) const SetConstructorExpr::SetConstructorExpr(ListExprPtr constructor_list, std::unique_ptr> arg_attrs, - zeek::TypePtr arg_type) + TypePtr arg_type) : UnaryExpr(EXPR_SET_CONSTRUCTOR, std::move(constructor_list)) { if ( IsError() ) @@ -3233,7 +3233,7 @@ SetConstructorExpr::SetConstructorExpr(ListExprPtr constructor_list, else { if ( op->AsListExpr()->Exprs().empty() ) - SetType(zeek::make_intrusive(zeek::make_intrusive(zeek::base_type(zeek::TYPE_ANY)), nullptr)); + SetType(make_intrusive(make_intrusive(base_type(TYPE_ANY)), nullptr)); else SetType(init_type(op.get())); } @@ -3241,11 +3241,11 @@ SetConstructorExpr::SetConstructorExpr(ListExprPtr constructor_list, if ( ! type ) SetError(); - else if ( type->Tag() != zeek::TYPE_TABLE || ! type->AsTableType()->IsSet() ) + else if ( type->Tag() != TYPE_TABLE || ! type->AsTableType()->IsSet() ) SetError("values in set(...) constructor do not specify a set"); if ( arg_attrs ) - attrs = zeek::make_intrusive(std::move(*arg_attrs), type, false, false); + attrs = make_intrusive(std::move(*arg_attrs), type, false, false); const auto& indices = type->AsTableType()->GetIndices()->GetTypes(); ExprPList& cle = op->AsListExpr()->Exprs(); @@ -3284,7 +3284,7 @@ ValPtr SetConstructorExpr::Eval(Frame* f) const if ( IsError() ) return nullptr; - auto aggr = zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, type->AsTableType()}, + auto aggr = make_intrusive(IntrusivePtr{NewRef{}, type->AsTableType()}, attrs); const ExprPList& exprs = op->AsListExpr()->Exprs(); @@ -3305,8 +3305,8 @@ ValPtr SetConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const const auto& index_type = t->AsTableType()->GetIndices(); auto tt = GetType(); auto tval = aggr ? - TableValPtr{zeek::AdoptRef{}, aggr.release()->AsTableVal()} : - zeek::make_intrusive(std::move(tt), attrs); + TableValPtr{AdoptRef{}, aggr.release()->AsTableVal()} : + make_intrusive(std::move(tt), attrs); const ExprPList& exprs = op->AsListExpr()->Exprs(); for ( const auto& e : exprs ) @@ -3315,7 +3315,7 @@ ValPtr SetConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( ! element || ! tval->Assign(std::move(element), nullptr) ) { - Error(zeek::util::fmt("initialization type mismatch in set"), e); + Error(util::fmt("initialization type mismatch in set"), e); return nullptr; } } @@ -3331,7 +3331,7 @@ void SetConstructorExpr::ExprDescribe(ODesc* d) const } VectorConstructorExpr::VectorConstructorExpr(ListExprPtr constructor_list, - zeek::TypePtr arg_type) + TypePtr arg_type) : UnaryExpr(EXPR_VECTOR_CONSTRUCTOR, std::move(constructor_list)) { if ( IsError() ) @@ -3339,7 +3339,7 @@ VectorConstructorExpr::VectorConstructorExpr(ListExprPtr constructor_list, if ( arg_type ) { - if ( arg_type->Tag() != zeek::TYPE_VECTOR ) + if ( arg_type->Tag() != TYPE_VECTOR ) { Error("bad vector constructor type", arg_type.get()); SetError(); @@ -3355,12 +3355,12 @@ VectorConstructorExpr::VectorConstructorExpr(ListExprPtr constructor_list, // vector(). // By default, assign VOID type here. A vector with // void type set is seen as an unspecified vector. - SetType(zeek::make_intrusive(zeek::base_type(zeek::TYPE_VOID))); + SetType(make_intrusive(base_type(TYPE_VOID))); return; } if ( auto t = merge_type_list(op->AsListExpr()) ) - SetType(zeek::make_intrusive(std::move(t))); + SetType(make_intrusive(std::move(t))); else { SetError(); @@ -3378,7 +3378,7 @@ ValPtr VectorConstructorExpr::Eval(Frame* f) const if ( IsError() ) return nullptr; - auto vec = zeek::make_intrusive(GetType()); + auto vec = make_intrusive(GetType()); const ExprPList& exprs = op->AsListExpr()->Exprs(); loop_over_list(exprs, i) @@ -3387,7 +3387,7 @@ ValPtr VectorConstructorExpr::Eval(Frame* f) const if ( ! vec->Assign(i, e->Eval(f)) ) { - RuntimeError(zeek::util::fmt("type mismatch at index %d", i)); + RuntimeError(util::fmt("type mismatch at index %d", i)); return nullptr; } } @@ -3400,10 +3400,10 @@ ValPtr VectorConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( IsError() ) return nullptr; - auto vt = GetType(); + auto vt = GetType(); auto vec = aggr ? - VectorValPtr{zeek::AdoptRef{}, aggr.release()->AsVectorVal()} : - zeek::make_intrusive(std::move(vt)); + VectorValPtr{AdoptRef{}, aggr.release()->AsVectorVal()} : + make_intrusive(std::move(vt)); const ExprPList& exprs = op->AsListExpr()->Exprs(); loop_over_list(exprs, i) @@ -3413,7 +3413,7 @@ ValPtr VectorConstructorExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( ! v || ! vec->Assign(i, std::move(v)) ) { - Error(zeek::util::fmt("initialization type mismatch at index %d", i), e); + Error(util::fmt("initialization type mismatch at index %d", i), e); return nullptr; } } @@ -3448,7 +3448,7 @@ void FieldAssignExpr::EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f int idx = rt->FieldOffset(field_name.c_str()); if ( idx < 0 ) - zeek::reporter->InternalError("Missing record field: %s", + reporter->InternalError("Missing record field: %s", field_name.c_str()); rec->Assign(idx, std::move(v)); @@ -3460,7 +3460,7 @@ bool FieldAssignExpr::IsRecordElement(TypeDecl* td) const if ( td ) { td->type = op->GetType(); - td->id = zeek::util::copy_string(field_name.c_str()); + td->id = util::copy_string(field_name.c_str()); } return true; @@ -3485,17 +3485,17 @@ ArithCoerceExpr::ArithCoerceExpr(ExprPtr arg_op, TypeTag t) if ( IsVector(bt) ) { - SetType(zeek::make_intrusive(zeek::base_type(t))); + SetType(make_intrusive(base_type(t))); vbt = op->GetType()->AsVectorType()->Yield()->Tag(); } else - SetType(zeek::base_type(t)); + SetType(base_type(t)); - if ( (bt == zeek::TYPE_ENUM) != (t == zeek::TYPE_ENUM) ) + if ( (bt == TYPE_ENUM) != (t == TYPE_ENUM) ) ExprError("can't convert to/from enumerated type"); else if ( ! IsArithmetic(t) && ! IsBool(t) && - t != zeek::TYPE_TIME && t != zeek::TYPE_INTERVAL ) + t != TYPE_TIME && t != TYPE_INTERVAL ) ExprError("bad coercion"); else if ( ! IsArithmetic(bt) && ! IsBool(bt) && @@ -3506,14 +3506,14 @@ ArithCoerceExpr::ArithCoerceExpr(ExprPtr arg_op, TypeTag t) ValPtr ArithCoerceExpr::FoldSingleVal(Val* v, InternalTypeTag t) const { switch ( t ) { - case zeek::TYPE_INTERNAL_DOUBLE: - return zeek::make_intrusive(v->CoerceToDouble()); + case TYPE_INTERNAL_DOUBLE: + return make_intrusive(v->CoerceToDouble()); - case zeek::TYPE_INTERNAL_INT: - return zeek::val_mgr->Int(v->CoerceToInt()); + case TYPE_INTERNAL_INT: + return val_mgr->Int(v->CoerceToInt()); - case zeek::TYPE_INTERNAL_UNSIGNED: - return zeek::val_mgr->Count(v->CoerceToUnsigned()); + case TYPE_INTERNAL_UNSIGNED: + return val_mgr->Count(v->CoerceToUnsigned()); default: RuntimeErrorWithCallStack("bad type in CoerceExpr::Fold"); @@ -3530,7 +3530,7 @@ ValPtr ArithCoerceExpr::Fold(Val* v) const // Our result type might be vector, in which case this // invocation is being done per-element rather than on // the whole vector. Correct the type tag if necessary. - if ( type->Tag() == zeek::TYPE_VECTOR ) + if ( type->Tag() == TYPE_VECTOR ) t = GetType()->AsVectorType()->Yield()->InternalType(); return FoldSingleVal(v, t); @@ -3539,7 +3539,7 @@ ValPtr ArithCoerceExpr::Fold(Val* v) const t = GetType()->AsVectorType()->Yield()->InternalType(); VectorVal* vv = v->AsVectorVal(); - auto result = zeek::make_intrusive(GetType()); + auto result = make_intrusive(GetType()); for ( unsigned int i = 0; i < vv->Size(); ++i ) { @@ -3552,7 +3552,7 @@ ValPtr ArithCoerceExpr::Fold(Val* v) const return result; } -RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) +RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, RecordTypePtr r) : UnaryExpr(EXPR_RECORD_COERCE, std::move(arg_op)), map(nullptr), map_size(0) { @@ -3561,10 +3561,10 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) SetType(std::move(r)); - if ( GetType()->Tag() != zeek::TYPE_RECORD ) + if ( GetType()->Tag() != TYPE_RECORD ) ExprError("coercion to non-record"); - else if ( op->GetType()->Tag() != zeek::TYPE_RECORD ) + else if ( op->GetType()->Tag() != TYPE_RECORD ) ExprError("coercion of non-record to record"); else @@ -3584,7 +3584,7 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) int t_i = t_r->FieldOffset(sub_r->FieldName(i)); if ( t_i < 0 ) { - ExprError(zeek::util::fmt("orphaned field \"%s\" in record coercion", + ExprError(util::fmt("orphaned field \"%s\" in record coercion", sub_r->FieldName(i))); break; } @@ -3602,10 +3602,10 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) if ( ! BothArithmetic(sup_tag, sub_tag) ) return false; - if ( sub_tag == zeek::TYPE_DOUBLE && IsIntegral(sup_tag) ) + if ( sub_tag == TYPE_DOUBLE && IsIntegral(sup_tag) ) return false; - if ( sub_tag == zeek::TYPE_INT && sup_tag == zeek::TYPE_COUNT ) + if ( sub_tag == TYPE_INT && sup_tag == TYPE_COUNT ) return false; return true; @@ -3613,10 +3613,10 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) auto is_record_promotable = [](zeek::Type* sup, zeek::Type* sub) -> bool { - if ( sup->Tag() != zeek::TYPE_RECORD ) + if ( sup->Tag() != TYPE_RECORD ) return false; - if ( sub->Tag() != zeek::TYPE_RECORD ) + if ( sub->Tag() != TYPE_RECORD ) return false; return record_promotion_compatible(sup->AsRecordType(), @@ -3626,7 +3626,7 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) if ( ! is_arithmetic_promotable(sup_t_i.get(), sub_t_i.get()) && ! is_record_promotable(sup_t_i.get(), sub_t_i.get()) ) { - std::string error_msg = zeek::util::fmt( + std::string error_msg = util::fmt( "type clash for field \"%s\"", sub_r->FieldName(i)); Error(error_msg.c_str(), sub_t_i.get()); SetError(); @@ -3646,7 +3646,7 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) { if ( ! t_r->FieldDecl(i)->GetAttr(ATTR_OPTIONAL) ) { - std::string error_msg = zeek::util::fmt( + std::string error_msg = util::fmt( "non-optional field \"%s\" missing", t_r->FieldName(i)); Error(error_msg.c_str()); SetError(); @@ -3654,7 +3654,7 @@ RecordCoerceExpr::RecordCoerceExpr(ExprPtr arg_op, zeek::RecordTypePtr r) } } else if ( t_r->IsFieldDeprecated(i) ) - zeek::reporter->Warning("%s", t_r->GetFieldDeprecationWarning(i, false).c_str()); + reporter->Warning("%s", t_r->GetFieldDeprecationWarning(i, false).c_str()); } } } @@ -3670,8 +3670,8 @@ ValPtr RecordCoerceExpr::InitVal(const zeek::Type* t, ValPtr aggr) const { RecordVal* rv = v->AsRecordVal(); auto bt = const_cast(t); - zeek::RecordTypePtr rt{zeek::NewRef{}, bt->AsRecordType()}; - auto aggr_rec = zeek::cast_intrusive(std::move(aggr)); + RecordTypePtr rt{NewRef{}, bt->AsRecordType()}; + auto aggr_rec = cast_intrusive(std::move(aggr)); if ( auto ar = rv->CoerceTo(std::move(rt), std::move(aggr_rec)) ) return ar; @@ -3683,7 +3683,7 @@ ValPtr RecordCoerceExpr::InitVal(const zeek::Type* t, ValPtr aggr) const ValPtr RecordCoerceExpr::Fold(Val* v) const { - auto val = zeek::make_intrusive(GetType()); + auto val = make_intrusive(GetType()); RecordType* val_type = val->GetType()->AsRecordType(); RecordVal* rv = v->AsRecordVal(); @@ -3715,11 +3715,11 @@ ValPtr RecordCoerceExpr::Fold(Val* v) const const auto& rhs_type = rhs->GetType(); const auto& field_type = val_type->GetFieldType(i); - if ( rhs_type->Tag() == zeek::TYPE_RECORD && - field_type->Tag() == zeek::TYPE_RECORD && + if ( rhs_type->Tag() == TYPE_RECORD && + field_type->Tag() == TYPE_RECORD && ! same_type(rhs_type, field_type) ) { - if ( auto new_val = rhs->AsRecordVal()->CoerceTo(zeek::cast_intrusive(field_type)) ) + if ( auto new_val = rhs->AsRecordVal()->CoerceTo(cast_intrusive(field_type)) ) rhs = std::move(new_val); } else if ( BothArithmetic(rhs_type->Tag(), field_type->Tag()) && @@ -3741,12 +3741,12 @@ ValPtr RecordCoerceExpr::Fold(Val* v) const const auto& def_type = def_val->GetType(); const auto& field_type = GetType()->AsRecordType()->GetFieldType(i); - if ( def_type->Tag() == zeek::TYPE_RECORD && - field_type->Tag() == zeek::TYPE_RECORD && + if ( def_type->Tag() == TYPE_RECORD && + field_type->Tag() == TYPE_RECORD && ! same_type(def_type, field_type) ) { auto tmp = def_val->AsRecordVal()->CoerceTo( - zeek::cast_intrusive(field_type)); + cast_intrusive(field_type)); if ( tmp ) def_val = std::move(tmp); @@ -3762,7 +3762,7 @@ ValPtr RecordCoerceExpr::Fold(Val* v) const return val; } -TableCoerceExpr::TableCoerceExpr(ExprPtr arg_op, zeek::TableTypePtr r) +TableCoerceExpr::TableCoerceExpr(ExprPtr arg_op, TableTypePtr r) : UnaryExpr(EXPR_TABLE_COERCE, std::move(arg_op)) { if ( IsError() ) @@ -3770,10 +3770,10 @@ TableCoerceExpr::TableCoerceExpr(ExprPtr arg_op, zeek::TableTypePtr r) SetType(std::move(r)); - if ( GetType()->Tag() != zeek::TYPE_TABLE ) + if ( GetType()->Tag() != TYPE_TABLE ) ExprError("coercion to non-table"); - else if ( op->GetType()->Tag() != zeek::TYPE_TABLE ) + else if ( op->GetType()->Tag() != TYPE_TABLE ) ExprError("coercion of non-table/set to table/set"); } @@ -3789,10 +3789,10 @@ ValPtr TableCoerceExpr::Fold(Val* v) const if ( tv->Size() > 0 ) RuntimeErrorWithCallStack("coercion of non-empty table/set"); - return zeek::make_intrusive(GetType(), tv->GetAttrs()); + return make_intrusive(GetType(), tv->GetAttrs()); } -VectorCoerceExpr::VectorCoerceExpr(ExprPtr arg_op, zeek::VectorTypePtr v) +VectorCoerceExpr::VectorCoerceExpr(ExprPtr arg_op, VectorTypePtr v) : UnaryExpr(EXPR_VECTOR_COERCE, std::move(arg_op)) { if ( IsError() ) @@ -3800,10 +3800,10 @@ VectorCoerceExpr::VectorCoerceExpr(ExprPtr arg_op, zeek::VectorTypePtr v) SetType(std::move(v)); - if ( GetType()->Tag() != zeek::TYPE_VECTOR ) + if ( GetType()->Tag() != TYPE_VECTOR ) ExprError("coercion to non-vector"); - else if ( op->GetType()->Tag() != zeek::TYPE_VECTOR ) + else if ( op->GetType()->Tag() != TYPE_VECTOR ) ExprError("coercion of non-vector to vector"); } @@ -3819,10 +3819,10 @@ ValPtr VectorCoerceExpr::Fold(Val* v) const if ( vv->Size() > 0 ) RuntimeErrorWithCallStack("coercion of non-empty vector"); - return zeek::make_intrusive(GetType()); + return make_intrusive(GetType()); } -ScheduleTimer::ScheduleTimer(const EventHandlerPtr& arg_event, zeek::Args arg_args, +ScheduleTimer::ScheduleTimer(const EventHandlerPtr& arg_event, Args arg_args, double t) : Timer(t, TIMER_SCHEDULE), event(arg_event), args(std::move(arg_args)) @@ -3836,7 +3836,7 @@ ScheduleTimer::~ScheduleTimer() void ScheduleTimer::Dispatch(double /* t */, bool /* is_expire */) { if ( event ) - zeek::event_mgr.Enqueue(event, std::move(args)); + event_mgr.Enqueue(event, std::move(args)); } ScheduleExpr::ScheduleExpr(ExprPtr arg_when, EventExprPtr arg_event) @@ -3848,10 +3848,10 @@ ScheduleExpr::ScheduleExpr(ExprPtr arg_when, EventExprPtr arg_event) TypeTag bt = when->GetType()->Tag(); - if ( bt != zeek::TYPE_TIME && bt != zeek::TYPE_INTERVAL ) + if ( bt != TYPE_TIME && bt != TYPE_INTERVAL ) ExprError("schedule expression requires a time or time interval"); else - SetType(zeek::base_type(zeek::TYPE_TIMER)); + SetType(base_type(TYPE_TIMER)); } bool ScheduleExpr::IsPure() const @@ -3861,7 +3861,7 @@ bool ScheduleExpr::IsPure() const ValPtr ScheduleExpr::Eval(Frame* f) const { - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) return nullptr; auto when_val = when->Eval(f); @@ -3871,8 +3871,8 @@ ValPtr ScheduleExpr::Eval(Frame* f) const double dt = when_val->InternalDouble(); - if ( when->GetType()->Tag() == zeek::TYPE_INTERVAL ) - dt += zeek::run_state::network_time; + if ( when->GetType()->Tag() == TYPE_INTERVAL ) + dt += run_state::network_time; auto args = eval_list(f, event->Args()); @@ -3923,20 +3923,20 @@ InExpr::InExpr(ExprPtr arg_op1, ExprPtr arg_op2) if ( IsError() ) return; - if ( op1->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( op1->GetType()->Tag() == TYPE_PATTERN ) { - if ( op2->GetType()->Tag() != zeek::TYPE_STRING ) + if ( op2->GetType()->Tag() != TYPE_STRING ) { op2->GetType()->Error("pattern requires string index", op1.get()); SetError(); } else - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } - else if ( op1->GetType()->Tag() == zeek::TYPE_RECORD ) + else if ( op1->GetType()->Tag() == TYPE_RECORD ) { - if ( op2->GetType()->Tag() != zeek::TYPE_TABLE ) + if ( op2->GetType()->Tag() != TYPE_TABLE ) { op2->GetType()->Error("table/set required"); SetError(); @@ -3953,79 +3953,79 @@ InExpr::InExpr(ExprPtr arg_op1, ExprPtr arg_op2) SetError(); } else - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } } - else if ( op1->GetType()->Tag() == zeek::TYPE_STRING && - op2->GetType()->Tag() == zeek::TYPE_STRING ) - SetType(zeek::base_type(zeek::TYPE_BOOL)); + else if ( op1->GetType()->Tag() == TYPE_STRING && + op2->GetType()->Tag() == TYPE_STRING ) + SetType(base_type(TYPE_BOOL)); else { // Check for: in // in set[subnet] // in table[subnet] of ... - if ( op1->GetType()->Tag() == zeek::TYPE_ADDR ) + if ( op1->GetType()->Tag() == TYPE_ADDR ) { - if ( op2->GetType()->Tag() == zeek::TYPE_SUBNET ) + if ( op2->GetType()->Tag() == TYPE_SUBNET ) { - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); return; } - if ( op2->GetType()->Tag() == zeek::TYPE_TABLE && + if ( op2->GetType()->Tag() == TYPE_TABLE && op2->GetType()->AsTableType()->IsSubNetIndex() ) { - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); return; } } if ( op1->Tag() != EXPR_LIST ) - op1 = zeek::make_intrusive(std::move(op1)); + op1 = make_intrusive(std::move(op1)); ListExpr* lop1 = op1->AsListExpr(); if ( ! op2->GetType()->MatchesIndex(lop1) ) SetError("not an index type"); else - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } } ValPtr InExpr::Fold(Val* v1, Val* v2) const { - if ( v1->GetType()->Tag() == zeek::TYPE_PATTERN ) + if ( v1->GetType()->Tag() == TYPE_PATTERN ) { RE_Matcher* re = v1->AsPattern(); const String* s = v2->AsString(); - return zeek::val_mgr->Bool(re->MatchAnywhere(s) != 0); + return val_mgr->Bool(re->MatchAnywhere(s) != 0); } - if ( v2->GetType()->Tag() == zeek::TYPE_STRING ) + if ( v2->GetType()->Tag() == TYPE_STRING ) { const String* s1 = v1->AsString(); const String* s2 = v2->AsString(); // Could do better here e.g. Boyer-Moore if done repeatedly. auto s = reinterpret_cast(s1->CheckString()); - auto res = zeek::util::strstr_n(s2->Len(), s2->Bytes(), s1->Len(), s) != -1; - return zeek::val_mgr->Bool(res); + auto res = util::strstr_n(s2->Len(), s2->Bytes(), s1->Len(), s) != -1; + return val_mgr->Bool(res); } - if ( v1->GetType()->Tag() == zeek::TYPE_ADDR && - v2->GetType()->Tag() == zeek::TYPE_SUBNET ) - return zeek::val_mgr->Bool(v2->AsSubNetVal()->Contains(v1->AsAddr())); + if ( v1->GetType()->Tag() == TYPE_ADDR && + v2->GetType()->Tag() == TYPE_SUBNET ) + return val_mgr->Bool(v2->AsSubNetVal()->Contains(v1->AsAddr())); bool res; if ( is_vector(v2) ) res = (bool)v2->AsVectorVal()->At(v1->AsListVal()->Idx(0)->CoerceToUnsigned()); else - res = (bool)v2->AsTableVal()->Find({zeek::NewRef{}, v1}); + res = (bool)v2->AsTableVal()->Find({NewRef{}, v1}); - return zeek::val_mgr->Bool(res); + return val_mgr->Bool(res); } CallExpr::CallExpr(ExprPtr arg_func, ListExprPtr arg_args, bool in_hook) @@ -4096,14 +4096,14 @@ CallExpr::CallExpr(ExprPtr arg_func, ListExprPtr arg_args, bool in_hook) // run-time errors when we apply this analysis during // parsing. Really we should instead do it after we've // parsed the entire set of scripts. - zeek::util::streq(((NameExpr*) func.get())->Id()->Name(), "fmt") && + util::streq(((NameExpr*) func.get())->Id()->Name(), "fmt") && // The following is needed because fmt might not yet // be bound as a name. did_builtin_init && (func_val = func->Eval(nullptr)) ) { zeek::Func* f = func_val->AsFunc(); - if ( f->GetKind() == zeek::Func::BUILTIN_FUNC && + if ( f->GetKind() == Func::BUILTIN_FUNC && ! check_built_in_call((BuiltinFunc*) f, this) ) SetError(); } @@ -4131,7 +4131,7 @@ bool CallExpr::IsPure() const // or indirectly). bool pure = false; - if ( f->GetKind() == zeek::Func::BUILTIN_FUNC ) + if ( f->GetKind() == Func::BUILTIN_FUNC ) pure = f->IsPure() && args->IsPure(); return pure; @@ -4151,10 +4151,10 @@ ValPtr CallExpr::Eval(Frame* f) const { if ( Val* v = trigger->Lookup(this) ) { - DBG_LOG(zeek::DBG_NOTIFIERS, + DBG_LOG(DBG_NOTIFIERS, "%s: provides cached function result", trigger->Name()); - return {zeek::NewRef{}, v}; + return {NewRef{}, v}; } } } @@ -4219,7 +4219,7 @@ LambdaExpr::LambdaExpr(std::unique_ptr arg_ing, // Install a dummy version of the function globally for use only // when broker provides a closure. - auto dummy_func = zeek::make_intrusive( + auto dummy_func = make_intrusive( ingredients->id, ingredients->body, ingredients->inits, @@ -4257,7 +4257,7 @@ LambdaExpr::LambdaExpr(std::unique_ptr arg_ing, // Update lamb's name dummy_func->SetName(my_name.c_str()); - auto v = zeek::make_intrusive(std::move(dummy_func)); + auto v = make_intrusive(std::move(dummy_func)); id->SetVal(std::move(v)); id->SetType(ingredients->id->GetType()); id->SetConst(); @@ -4270,7 +4270,7 @@ Scope* LambdaExpr::GetScope() const ValPtr LambdaExpr::Eval(Frame* f) const { - auto lamb = zeek::make_intrusive( + auto lamb = make_intrusive( ingredients->id, ingredients->body, ingredients->inits, @@ -4283,7 +4283,7 @@ ValPtr LambdaExpr::Eval(Frame* f) const // Allows for lookups by the receiver. lamb->SetName(my_name.c_str()); - return zeek::make_intrusive(std::move(lamb)); + return make_intrusive(std::move(lamb)); } void LambdaExpr::ExprDescribe(ODesc* d) const @@ -4307,12 +4307,12 @@ TraversalCode LambdaExpr::Traverse(TraversalCallback* cb) const EventExpr::EventExpr(const char* arg_name, ListExprPtr arg_args) : Expr(EXPR_EVENT), name(arg_name), args(std::move(arg_args)) { - EventHandler* h = zeek::event_registry->Lookup(name); + EventHandler* h = event_registry->Lookup(name); if ( ! h ) { h = new EventHandler(name.c_str()); - zeek::event_registry->Register(h); + event_registry->Register(h); } h->SetUsed(); @@ -4354,7 +4354,7 @@ ValPtr EventExpr::Eval(Frame* f) const auto v = eval_list(f, args.get()); if ( handler ) - zeek::event_mgr.Enqueue(handler, std::move(*v)); + event_mgr.Enqueue(handler, std::move(*v)); return nullptr; } @@ -4386,12 +4386,12 @@ void EventExpr::ExprDescribe(ODesc* d) const ListExpr::ListExpr() : Expr(EXPR_LIST) { - SetType(zeek::make_intrusive()); + SetType(make_intrusive()); } ListExpr::ListExpr(ExprPtr e) : Expr(EXPR_LIST) { - SetType(zeek::make_intrusive()); + SetType(make_intrusive()); Append(std::move(e)); } @@ -4418,7 +4418,7 @@ bool ListExpr::IsPure() const ValPtr ListExpr::Eval(Frame* f) const { - auto v = zeek::make_intrusive(zeek::TYPE_ANY); + auto v = make_intrusive(TYPE_ANY); for ( const auto& expr : exprs ) { @@ -4436,7 +4436,7 @@ ValPtr ListExpr::Eval(Frame* f) const return v; } -zeek::TypePtr ListExpr::InitType() const +TypePtr ListExpr::InitType() const { if ( exprs.empty() ) { @@ -4462,19 +4462,19 @@ zeek::TypePtr ListExpr::InitType() const } - return zeek::make_intrusive(types); + return make_intrusive(types); } else { - auto tl = zeek::make_intrusive(); + auto tl = make_intrusive(); for ( const auto& e : exprs ) { const auto& ti = e->GetType(); // Collapse any embedded sets or lists. - if ( ti->IsSet() || ti->Tag() == zeek::TYPE_LIST ) + if ( ti->IsSet() || ti->Tag() == TYPE_LIST ) { TypeList* til = ti->IsSet() ? ti->AsSetType()->GetIndices().get() : @@ -4482,7 +4482,7 @@ zeek::TypePtr ListExpr::InitType() const if ( ! til->IsPure() || ! til->AllMatch(til->GetPureType(), true) ) - tl->Append({zeek::NewRef{}, til}); + tl->Append({NewRef{}, til}); else tl->Append(til->GetPureType()); } @@ -4507,7 +4507,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const // in which case we should expand as a ListVal. if ( ! aggr && type->AsTypeList()->AllMatch(t, true) ) { - auto v = zeek::make_intrusive(zeek::TYPE_ANY); + auto v = make_intrusive(TYPE_ANY); const auto& tl = type->AsTypeList()->GetTypes(); if ( exprs.length() != static_cast(tl.size()) ) @@ -4528,7 +4528,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const return v; } - if ( t->Tag() == zeek::TYPE_LIST ) + if ( t->Tag() == TYPE_LIST ) { if ( aggr ) { @@ -4544,7 +4544,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const return nullptr; } - auto v = zeek::make_intrusive(zeek::TYPE_ANY); + auto v = make_intrusive(TYPE_ANY); loop_over_list(exprs, i) { @@ -4559,8 +4559,8 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const return v; } - if ( t->Tag() != zeek::TYPE_RECORD && t->Tag() != zeek::TYPE_TABLE && - t->Tag() != zeek::TYPE_VECTOR ) + if ( t->Tag() != TYPE_RECORD && t->Tag() != TYPE_TABLE && + t->Tag() != TYPE_VECTOR ) { if ( exprs.length() == 1 ) // Allow "global x:int = { 5 }" @@ -4578,7 +4578,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( t->IsSet() ) return AddSetInit(t, std::move(aggr)); - if ( t->Tag() == zeek::TYPE_VECTOR ) + if ( t->Tag() == TYPE_VECTOR ) { // v: vector = [10, 20, 30]; VectorVal* vec = aggr->AsVectorVal(); @@ -4594,7 +4594,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const if ( ! vec->Assign(i, e->Eval(nullptr)) ) { - e->Error(zeek::util::fmt("type mismatch at index %d", i)); + e->Error(util::fmt("type mismatch at index %d", i)); return nullptr; } } @@ -4616,7 +4616,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const } else { - if ( t->Tag() == zeek::TYPE_RECORD ) + if ( t->Tag() == TYPE_RECORD ) { e->Error("bad record initializer", t); return nullptr; @@ -4640,7 +4640,7 @@ ValPtr ListExpr::InitVal(const zeek::Type* t, ValPtr aggr) const ValPtr ListExpr::AddSetInit(const zeek::Type* t, ValPtr aggr) const { - if ( aggr->GetType()->Tag() != zeek::TYPE_TABLE ) + if ( aggr->GetType()->Tag() != TYPE_TABLE ) Internal("bad aggregate in ListExpr::InitVal"); TableVal* tv = aggr->AsTableVal(); @@ -4654,7 +4654,7 @@ ValPtr ListExpr::AddSetInit(const zeek::Type* t, ValPtr aggr) const if ( expr->GetType()->IsSet() ) // A set to flatten. element = expr->Eval(nullptr); - else if ( expr->GetType()->Tag() == zeek::TYPE_LIST ) + else if ( expr->GetType()->Tag() == TYPE_LIST ) element = expr->InitVal(it, nullptr); else element = expr->InitVal(it->GetTypes()[0].get(), nullptr); @@ -4676,7 +4676,7 @@ ValPtr ListExpr::AddSetInit(const zeek::Type* t, ValPtr aggr) const continue; } - if ( expr->GetType()->Tag() == zeek::TYPE_LIST ) + if ( expr->GetType()->Tag() == TYPE_LIST ) element = check_and_promote(std::move(element), it, true); else element = check_and_promote(std::move(element), it->GetTypes()[0].get(), true); @@ -4710,7 +4710,7 @@ ExprPtr ListExpr::MakeLvalue() if ( expr->Tag() != EXPR_NAME ) ExprError("can only assign to list of identifiers"); - return zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, this}); + return make_intrusive(IntrusivePtr{NewRef{}, this}); } void ListExpr::Assign(Frame* f, ValPtr v) @@ -4753,7 +4753,7 @@ RecordAssignExpr::RecordAssignExpr(const ExprPtr& record, for ( const auto& init : inits ) { - if ( init->GetType()->Tag() == zeek::TYPE_RECORD ) + if ( init->GetType()->Tag() == TYPE_RECORD ) { RecordType* t = init->GetType()->AsRecordType(); @@ -4765,8 +4765,8 @@ RecordAssignExpr::RecordAssignExpr(const ExprPtr& record, if ( field >= 0 && same_type(lhs->GetFieldType(field), t->GetFieldType(j)) ) { - auto fe_lhs = zeek::make_intrusive(record, field_name); - auto fe_rhs = zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, init}, field_name); + auto fe_lhs = make_intrusive(record, field_name); + auto fe_rhs = make_intrusive(IntrusivePtr{NewRef{}, init}, field_name); Append(get_assign_expr(std::move(fe_lhs), std::move(fe_rhs), is_init)); } } @@ -4780,8 +4780,8 @@ RecordAssignExpr::RecordAssignExpr(const ExprPtr& record, const char* field_name = ""; // rf->FieldName(); if ( lhs->HasField(field_name) ) { - auto fe_lhs = zeek::make_intrusive(record, field_name); - ExprPtr fe_rhs = {zeek::NewRef{}, rf->Op()}; + auto fe_lhs = make_intrusive(record, field_name); + ExprPtr fe_rhs = {NewRef{}, rf->Op()}; Append(get_assign_expr(std::move(fe_lhs), std::move(fe_rhs), is_init)); } else @@ -4801,7 +4801,7 @@ RecordAssignExpr::RecordAssignExpr(const ExprPtr& record, } } -CastExpr::CastExpr(ExprPtr arg_op, zeek::TypePtr t) +CastExpr::CastExpr(ExprPtr arg_op, TypePtr t) : UnaryExpr(EXPR_CAST, std::move(arg_op)) { auto stype = Op()->GetType(); @@ -4834,7 +4834,7 @@ ValPtr CastExpr::Eval(Frame* f) const GetType()->Describe(&d); d.Add("'"); - if ( same_type(v->GetType(), zeek::Broker::detail::DataVal::ScriptDataType()) && + if ( same_type(v->GetType(), Broker::detail::DataVal::ScriptDataType()) && ! v->AsRecordVal()->GetField(0) ) d.Add(" (nil $data field)"); @@ -4849,10 +4849,10 @@ void CastExpr::ExprDescribe(ODesc* d) const GetType()->Describe(d); } -IsExpr::IsExpr(ExprPtr arg_op, zeek::TypePtr arg_t) +IsExpr::IsExpr(ExprPtr arg_op, TypePtr arg_t) : UnaryExpr(EXPR_IS, std::move(arg_op)), t(std::move(arg_t)) { - SetType(zeek::base_type(zeek::TYPE_BOOL)); + SetType(base_type(TYPE_BOOL)); } ValPtr IsExpr::Fold(Val* v) const @@ -4860,7 +4860,7 @@ ValPtr IsExpr::Fold(Val* v) const if ( IsError() ) return nullptr; - return zeek::val_mgr->Bool(can_cast_value_to_type(v, t.get())); + return val_mgr->Bool(can_cast_value_to_type(v, t.get())); } void IsExpr::ExprDescribe(ODesc* d) const @@ -4872,17 +4872,17 @@ void IsExpr::ExprDescribe(ODesc* d) const ExprPtr get_assign_expr(ExprPtr op1, ExprPtr op2, bool is_init) { - if ( op1->GetType()->Tag() == zeek::TYPE_RECORD && - op2->GetType()->Tag() == zeek::TYPE_LIST ) - return zeek::make_intrusive( + if ( op1->GetType()->Tag() == TYPE_RECORD && + op2->GetType()->Tag() == TYPE_LIST ) + return make_intrusive( std::move(op1), std::move(op2), is_init); else if ( op1->Tag() == EXPR_INDEX && op1->AsIndexExpr()->IsSlice() ) - return zeek::make_intrusive( + return make_intrusive( std::move(op1), std::move(op2), is_init); else - return zeek::make_intrusive( + return make_intrusive( std::move(op1), std::move(op2), is_init); } @@ -4892,13 +4892,13 @@ ExprPtr check_and_promote_expr(Expr* const e, zeek::Type* t) TypeTag e_tag = et->Tag(); TypeTag t_tag = t->Tag(); - if ( t->Tag() == zeek::TYPE_ANY ) - return {zeek::NewRef{}, e}; + if ( t->Tag() == TYPE_ANY ) + return {NewRef{}, e}; if ( EitherArithmetic(t_tag, e_tag) ) { if ( e_tag == t_tag ) - return {zeek::NewRef{}, e}; + return {NewRef{}, e}; if ( ! BothArithmetic(t_tag, e_tag) ) { @@ -4913,10 +4913,10 @@ ExprPtr check_and_promote_expr(Expr* const e, zeek::Type* t) return nullptr; } - return zeek::make_intrusive(IntrusivePtr{zeek::NewRef{}, e}, t_tag); + return make_intrusive(IntrusivePtr{NewRef{}, e}, t_tag); } - if ( t->Tag() == zeek::TYPE_RECORD && et->Tag() == zeek::TYPE_RECORD ) + if ( t->Tag() == TYPE_RECORD && et->Tag() == TYPE_RECORD ) { RecordType* t_r = t->AsRecordType(); RecordType* et_r = et->AsRecordType(); @@ -4931,14 +4931,14 @@ ExprPtr check_and_promote_expr(Expr* const e, zeek::Type* t) if ( same_attrs(td1->attrs.get(), td2->attrs.get()) ) // Everything matches perfectly. - return {zeek::NewRef{}, e}; + return {NewRef{}, e}; } } if ( record_promotion_compatible(t_r, et_r) ) - return zeek::make_intrusive( - IntrusivePtr{zeek::NewRef{}, e}, - IntrusivePtr{zeek::NewRef{}, t_r}); + return make_intrusive( + IntrusivePtr{NewRef{}, e}, + IntrusivePtr{NewRef{}, t_r}); t->Error("incompatible record types", e); return nullptr; @@ -4947,23 +4947,23 @@ ExprPtr check_and_promote_expr(Expr* const e, zeek::Type* t) if ( ! same_type(t, et) ) { - if ( t->Tag() == zeek::TYPE_TABLE && et->Tag() == zeek::TYPE_TABLE && + if ( t->Tag() == TYPE_TABLE && et->Tag() == TYPE_TABLE && et->AsTableType()->IsUnspecifiedTable() ) - return zeek::make_intrusive( - IntrusivePtr{zeek::NewRef{}, e}, - IntrusivePtr{zeek::NewRef{}, t->AsTableType()}); + return make_intrusive( + IntrusivePtr{NewRef{}, e}, + IntrusivePtr{NewRef{}, t->AsTableType()}); - if ( t->Tag() == zeek::TYPE_VECTOR && et->Tag() == zeek::TYPE_VECTOR && + if ( t->Tag() == TYPE_VECTOR && et->Tag() == TYPE_VECTOR && et->AsVectorType()->IsUnspecifiedVector() ) - return zeek::make_intrusive( - IntrusivePtr{zeek::NewRef{}, e}, - IntrusivePtr{zeek::NewRef{}, t->AsVectorType()}); + return make_intrusive( + IntrusivePtr{NewRef{}, e}, + IntrusivePtr{NewRef{}, t->AsVectorType()}); t->Error("type clash", e); return nullptr; } - return {zeek::NewRef{}, e}; + return {NewRef{}, e}; } bool check_and_promote_exprs(ListExpr* const elements, TypeList* types) @@ -4971,7 +4971,7 @@ bool check_and_promote_exprs(ListExpr* const elements, TypeList* types) ExprPList& el = elements->Exprs(); const auto& tl = types->GetTypes(); - if ( tl.size() == 1 && tl[0]->Tag() == zeek::TYPE_ANY ) + if ( tl.size() == 1 && tl[0]->Tag() == TYPE_ANY ) return true; if ( el.length() != static_cast(tl.size()) ) @@ -5007,7 +5007,7 @@ bool check_and_promote_args(ListExpr* const args, RecordType* types) int ntypes = types->NumFields(); // give variadic BIFs automatic pass - if ( ntypes == 1 && types->FieldDecl(0)->type->Tag() == zeek::TYPE_ANY ) + if ( ntypes == 1 && types->FieldDecl(0)->type->Tag() == TYPE_ANY ) return true; if ( el.length() < ntypes ) @@ -5049,7 +5049,7 @@ bool check_and_promote_exprs_to_type(ListExpr* const elements, zeek::Type* type) { ExprPList& el = elements->Exprs(); - if ( type->Tag() == zeek::TYPE_ANY ) + if ( type->Tag() == TYPE_ANY ) return true; loop_over_list(el, i) @@ -5097,4 +5097,4 @@ bool expr_greater(const Expr* e1, const Expr* e2) return e1->Tag() > e2->Tag(); } -} +} // namespace zeek::detail diff --git a/src/Expr.h b/src/Expr.h index dc98649e86..6838955ffa 100644 --- a/src/Expr.h +++ b/src/Expr.h @@ -28,7 +28,7 @@ template class IntrusivePtr; namespace detail { -using IDPtr = zeek::IntrusivePtr; +using IDPtr = IntrusivePtr; enum BroExprTag : int { EXPR_ANY = -1, @@ -80,21 +80,21 @@ class EventExpr; class Stmt; class Expr; -using ExprPtr = zeek::IntrusivePtr; -using EventExprPtr = zeek::IntrusivePtr; -using ListExprPtr = zeek::IntrusivePtr; +using ExprPtr = IntrusivePtr; +using EventExprPtr = IntrusivePtr; +using ListExprPtr = IntrusivePtr; class Expr : public Obj { public: [[deprecated("Remove in v4.1. Use GetType().")]] zeek::Type* Type() const { return type.get(); } - const zeek::TypePtr& GetType() const + const TypePtr& GetType() const { return type; } template - zeek::IntrusivePtr GetType() const - { return zeek::cast_intrusive(type); } + IntrusivePtr GetType() const + { return cast_intrusive(type); } BroExprTag Tag() const { return tag; } @@ -115,7 +115,7 @@ public: // Returns the type corresponding to this expression interpreted // as an initialization. Returns nil if the initialization is illegal. - virtual zeek::TypePtr InitType() const; + virtual TypePtr InitType() const; // Returns true if this expression, interpreted as an initialization, // constitutes a record element, false otherwise. If the TypeDecl* @@ -197,7 +197,7 @@ protected: // Puts the expression in canonical form. virtual void Canonicize(); - void SetType(zeek::TypePtr t); + void SetType(TypePtr t); // Reports the given error and sets the expression's type to // TYPE_ERROR. @@ -209,13 +209,13 @@ protected: [[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const; BroExprTag tag; - zeek::TypePtr type; + TypePtr type; bool paren; }; class NameExpr final : public Expr { public: - explicit NameExpr(zeek::detail::IDPtr id, bool const_init = false); + explicit NameExpr(IDPtr id, bool const_init = false); ID* Id() const { return id.get(); } @@ -229,7 +229,7 @@ public: protected: void ExprDescribe(ODesc* d) const override; - zeek::detail::IDPtr id; + IDPtr id; bool in_const_init; }; @@ -499,7 +499,7 @@ public: ValPtr Eval(Frame* f) const override; void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override; - zeek::TypePtr InitType() const override; + TypePtr InitType() const override; bool IsRecordElement(TypeDecl* td) const override; ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override; bool IsPure() const override; @@ -608,7 +608,7 @@ class TableConstructorExpr final : public UnaryExpr { public: TableConstructorExpr(ListExprPtr constructor_list, std::unique_ptr> attrs, - zeek::TypePtr arg_type = nullptr); + TypePtr arg_type = nullptr); [[deprecated("Remove in v4.1. Use GetAttrs().")]] Attributes* Attrs() { return attrs.get(); } @@ -630,7 +630,7 @@ class SetConstructorExpr final : public UnaryExpr { public: SetConstructorExpr(ListExprPtr constructor_list, std::unique_ptr> attrs, - zeek::TypePtr arg_type = nullptr); + TypePtr arg_type = nullptr); [[deprecated("Remove in v4.1. Use GetAttrs().")]] Attributes* Attrs() { return attrs.get(); } @@ -651,7 +651,7 @@ protected: class VectorConstructorExpr final : public UnaryExpr { public: explicit VectorConstructorExpr(ListExprPtr constructor_list, - zeek::TypePtr arg_type = nullptr); + TypePtr arg_type = nullptr); ValPtr Eval(Frame* f) const override; @@ -678,7 +678,7 @@ protected: class ArithCoerceExpr final : public UnaryExpr { public: - ArithCoerceExpr(ExprPtr op, zeek::TypeTag t); + ArithCoerceExpr(ExprPtr op, TypeTag t); protected: ValPtr FoldSingleVal(Val* v, InternalTypeTag t) const; @@ -842,7 +842,7 @@ public: ValPtr Eval(Frame* f) const override; - zeek::TypePtr InitType() const override; + TypePtr InitType() const override; ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override; ExprPtr MakeLvalue() override; void Assign(Frame* f, ValPtr v) override; @@ -865,7 +865,7 @@ public: class CastExpr final : public UnaryExpr { public: - CastExpr(ExprPtr op, zeek::TypePtr t); + CastExpr(ExprPtr op, TypePtr t); protected: ValPtr Eval(Frame* f) const override; @@ -874,14 +874,14 @@ protected: class IsExpr final : public UnaryExpr { public: - IsExpr(ExprPtr op, zeek::TypePtr t); + IsExpr(ExprPtr op, TypePtr t); protected: ValPtr Fold(Val* v) const override; void ExprDescribe(ODesc* d) const override; private: - zeek::TypePtr t; + TypePtr t; }; inline Val* Expr::ExprVal() const diff --git a/src/File.cc b/src/File.cc index 6ee202b084..b1227037aa 100644 --- a/src/File.cc +++ b/src/File.cc @@ -40,7 +40,7 @@ static void maximize_num_fds() { struct rlimit rl; if ( getrlimit(RLIMIT_NOFILE, &rl) < 0 ) - zeek::reporter->FatalError("maximize_num_fds(): getrlimit failed"); + reporter->FatalError("maximize_num_fds(): getrlimit failed"); if ( rl.rlim_max == RLIM_INFINITY ) { @@ -52,7 +52,7 @@ static void maximize_num_fds() rl.rlim_cur = rl.rlim_max; if ( setrlimit(RLIMIT_NOFILE, &rl) < 0 ) - zeek::reporter->FatalError("maximize_num_fds(): setrlimit failed"); + reporter->FatalError("maximize_num_fds(): setrlimit failed"); } File::File(FILE* arg_f) @@ -60,7 +60,7 @@ File::File(FILE* arg_f) Init(); f = arg_f; name = access = nullptr; - t = zeek::base_type(zeek::TYPE_STRING); + t = base_type(TYPE_STRING); is_open = (f != nullptr); } @@ -68,9 +68,9 @@ File::File(FILE* arg_f, const char* arg_name, const char* arg_access) { Init(); f = arg_f; - name = zeek::util::copy_string(arg_name); - access = zeek::util::copy_string(arg_access); - t = zeek::base_type(zeek::TYPE_STRING); + name = util::copy_string(arg_name); + access = util::copy_string(arg_access); + t = base_type(TYPE_STRING); is_open = (f != nullptr); } @@ -78,15 +78,15 @@ File::File(const char* arg_name, const char* arg_access) { Init(); f = nullptr; - name = zeek::util::copy_string(arg_name); - access = zeek::util::copy_string(arg_access); - t = zeek::base_type(zeek::TYPE_STRING); + name = util::copy_string(arg_name); + access = util::copy_string(arg_access); + t = base_type(TYPE_STRING); - if ( zeek::util::streq(name, "/dev/stdin") ) + if ( util::streq(name, "/dev/stdin") ) f = stdin; - else if ( zeek::util::streq(name, "/dev/stdout") ) + else if ( util::streq(name, "/dev/stdout") ) f = stdout; - else if ( zeek::util::streq(name, "/dev/stderr") ) + else if ( util::streq(name, "/dev/stderr") ) f = stderr; if ( f ) @@ -94,7 +94,7 @@ File::File(const char* arg_name, const char* arg_access) else if ( ! Open() ) { - zeek::reporter->Error("cannot open %s: %s", name, strerror(errno)); + reporter->Error("cannot open %s: %s", name, strerror(errno)); is_open = false; } } @@ -119,7 +119,7 @@ const char* File::Name() const bool File::Open(FILE* file, const char* mode) { static bool fds_maximized = false; - open_time = zeek::run_state::network_time ? zeek::run_state::network_time : zeek::util::current_time(); + open_time = run_state::network_time ? run_state::network_time : util::current_time(); if ( ! fds_maximized ) { @@ -191,7 +191,7 @@ FILE* File::Seek(long new_position) return nullptr; if ( fseek(f, new_position, SEEK_SET) < 0 ) - zeek::reporter->Error("seek failed"); + reporter->Error("seek failed"); return f; } @@ -202,7 +202,7 @@ void File::SetBuf(bool arg_buffered) return; if ( setvbuf(f, NULL, arg_buffered ? _IOFBF : _IOLBF, 0) != 0 ) - zeek::reporter->Error("setvbuf failed"); + reporter->Error("setvbuf failed"); buffered = arg_buffered; } @@ -259,7 +259,7 @@ void File::Describe(ODesc* d) const d->Add("(no type)"); } -void File::SetAttrs(zeek::detail::Attributes* arg_attrs) +void File::SetAttrs(detail::Attributes* arg_attrs) { if ( ! arg_attrs ) return; @@ -267,11 +267,11 @@ void File::SetAttrs(zeek::detail::Attributes* arg_attrs) attrs = arg_attrs; Ref(attrs); - if ( attrs->Find(zeek::detail::ATTR_RAW_OUTPUT) ) + if ( attrs->Find(detail::ATTR_RAW_OUTPUT) ) EnableRawOutput(); } -zeek::RecordVal* File::Rotate() +RecordVal* File::Rotate() { if ( ! is_open ) return nullptr; @@ -280,9 +280,9 @@ zeek::RecordVal* File::Rotate() if ( f == stdin || f == stdout || f == stderr ) return nullptr; - static auto rotate_info = zeek::id::find_type("rotate_info"); - auto* info = new zeek::RecordVal(rotate_info); - FILE* newf = zeek::util::detail::rotate_file(name, info); + static auto rotate_info = id::find_type("rotate_info"); + auto* info = new RecordVal(rotate_info); + FILE* newf = util::detail::rotate_file(name, info); if ( ! newf ) { @@ -290,7 +290,7 @@ zeek::RecordVal* File::Rotate() return nullptr; } - info->Assign(2, open_time); + info->Assign(2, open_time); Unlink(); @@ -330,9 +330,9 @@ void File::RaiseOpenEvent() if ( ! ::file_opened ) return; - FilePtr bf{zeek::NewRef{}, this}; - auto* event = new zeek::Event(::file_opened, {zeek::make_intrusive(std::move(bf))}); - zeek::event_mgr.Dispatch(event, true); + FilePtr bf{NewRef{}, this}; + auto* event = new Event(::file_opened, {make_intrusive(std::move(bf))}); + event_mgr.Dispatch(event, true); } double File::Size() @@ -341,7 +341,7 @@ double File::Size() struct stat s; if ( fstat(fileno(f), &s) < 0 ) { - zeek::reporter->Error("can't stat fd for %s: %s", name, strerror(errno)); + reporter->Error("can't stat fd for %s: %s", name, strerror(errno)); return 0; } @@ -352,9 +352,9 @@ FilePtr File::Get(const char* name) { for ( const auto &el : open_files ) if ( el.first == name ) - return {zeek::NewRef{}, el.second}; + return {NewRef{}, el.second}; - return zeek::make_intrusive(name, "w"); + return make_intrusive(name, "w"); } } // namespace zeek diff --git a/src/File.h b/src/File.h index 6833414f88..8029e94d0b 100644 --- a/src/File.h +++ b/src/File.h @@ -22,12 +22,12 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(RecordVal, zeek); namespace zeek { class Type; -using TypePtr = zeek::IntrusivePtr; +using TypePtr = IntrusivePtr; class File; -using FilePtr = zeek::IntrusivePtr; +using FilePtr = IntrusivePtr; -class File final : public zeek::Obj { +class File final : public Obj { public: explicit File(FILE* arg_f); File(FILE* arg_f, const char* filename, const char* access); @@ -46,9 +46,9 @@ public: void SetBuf(bool buffered); // false=line buffered, true=fully buffered [[deprecated("Remove in v4.1. Use GetType().")]] - zeek::Type* FType() const { return t.get(); } + Type* FType() const { return t.get(); } - const zeek::TypePtr& GetType() const + const TypePtr& GetType() const { return t; } // Whether the file is open in a general sense; it might @@ -63,10 +63,10 @@ public: void Describe(ODesc* d) const override; // Rotates the logfile. Returns rotate_info. - zeek::RecordVal* Rotate(); + RecordVal* Rotate(); // Set &raw_output attribute. - void SetAttrs(zeek::detail::Attributes* attrs); + void SetAttrs(detail::Attributes* attrs); // Returns the current size of the file, after fresh stat'ing. double Size(); @@ -85,7 +85,7 @@ public: protected: - friend class zeek::detail::PrintStmt; + friend class detail::PrintStmt; File() { Init(); } void Init(); @@ -109,10 +109,10 @@ protected: void RaiseOpenEvent(); FILE* f; - zeek::TypePtr t; + TypePtr t; char* name; char* access; - zeek::detail::Attributes* attrs; + detail::Attributes* attrs; double open_time; bool is_open; // whether the file is open in a general sense bool buffered; diff --git a/src/Flare.cc b/src/Flare.cc index 3dddef3a99..3c8013e632 100644 --- a/src/Flare.cc +++ b/src/Flare.cc @@ -6,7 +6,7 @@ #include #include -using namespace zeek::detail; +namespace zeek::detail { Flare::Flare() : pipe(FD_CLOEXEC, FD_CLOEXEC, O_NONBLOCK, O_NONBLOCK) @@ -19,10 +19,10 @@ Flare::Flare() abort(); char buf[256]; - zeek::util::zeek_strerror_r(errno, buf, sizeof(buf)); + util::zeek_strerror_r(errno, buf, sizeof(buf)); - if ( zeek::reporter ) - zeek::reporter->FatalErrorWithCore("unexpected pipe %s failure: %s", which, buf); + if ( reporter ) + reporter->FatalErrorWithCore("unexpected pipe %s failure: %s", which, buf); else { fprintf(stderr, "unexpected pipe %s failure: %s", which, buf); @@ -88,3 +88,5 @@ int Flare::Extinguish(bool signal_safe) return rval; } + +} // namespace zeek::detail diff --git a/src/Frag.cc b/src/Frag.cc index dff8f5cb1e..f8322e7317 100644 --- a/src/Frag.cc +++ b/src/Frag.cc @@ -26,11 +26,11 @@ void FragTimer::Dispatch(double t, bool /* is_expire */) if ( f ) f->Expire(t); else - zeek::reporter->InternalWarning("fragment timer dispatched w/o reassembler"); + reporter->InternalWarning("fragment timer dispatched w/o reassembler"); } -FragReassembler::FragReassembler(zeek::NetSessions* arg_s, - const zeek::IP_Hdr* ip, const u_char* pkt, +FragReassembler::FragReassembler(NetSessions* arg_s, + const IP_Hdr* ip, const u_char* pkt, const FragReassemblerKey& k, double t) : Reassembler(0, REASSEM_FRAG) { @@ -59,7 +59,7 @@ FragReassembler::FragReassembler(zeek::NetSessions* arg_s, if ( frag_timeout != 0.0 ) { expire_timer = new FragTimer(this, t + frag_timeout); - zeek::detail::timer_mgr->Add(expire_timer); + timer_mgr->Add(expire_timer); } else expire_timer = nullptr; @@ -74,7 +74,7 @@ FragReassembler::~FragReassembler() delete reassembled_pkt; } -void FragReassembler::AddFragment(double t, const zeek::IP_Hdr* ip, const u_char* pkt) +void FragReassembler::AddFragment(double t, const IP_Hdr* ip, const u_char* pkt) { const struct ip* ip4 = ip->IP4_Hdr(); @@ -155,7 +155,7 @@ void FragReassembler::AddFragment(double t, const zeek::IP_Hdr* ip, const u_char pkt += hdr_len; len -= hdr_len; - NewBlock(zeek::run_state::network_time, offset, len, pkt); + NewBlock(run_state::network_time, offset, len, pkt); } void FragReassembler::Weird(const char* name) const @@ -164,20 +164,20 @@ void FragReassembler::Weird(const char* name) const if ( version == 4 ) { - zeek::IP_Hdr hdr((const ip*)proto_hdr, false); + IP_Hdr hdr((const ip*)proto_hdr, false); s->Weird(name, &hdr); } else if ( version == 6 ) { - zeek::IP_Hdr hdr((const ip6_hdr*)proto_hdr, false, proto_hdr_len); + IP_Hdr hdr((const ip6_hdr*)proto_hdr, false, proto_hdr_len); s->Weird(name, &hdr); } else { - zeek::reporter->InternalWarning("Unexpected IP version in FragReassembler"); - zeek::reporter->Weird(name); + reporter->InternalWarning("Unexpected IP version in FragReassembler"); + reporter->Weird(name); } } @@ -277,9 +277,9 @@ void FragReassembler::BlockInserted(DataBlockMap::const_iterator /* it */) if ( b.upper > n ) { - zeek::reporter->InternalWarning("bad fragment reassembly"); + reporter->InternalWarning("bad fragment reassembly"); DeleteTimer(); - Expire(zeek::run_state::network_time); + Expire(run_state::network_time); delete [] pkt_start; return; } @@ -296,7 +296,7 @@ void FragReassembler::BlockInserted(DataBlockMap::const_iterator /* it */) { struct ip* reassem4 = (struct ip*) pkt_start; reassem4->ip_len = htons(frag_size + proto_hdr_len); - reassembled_pkt = new zeek::IP_Hdr(reassem4, true); + reassembled_pkt = new IP_Hdr(reassem4, true); DeleteTimer(); } @@ -304,14 +304,14 @@ void FragReassembler::BlockInserted(DataBlockMap::const_iterator /* it */) { struct ip6_hdr* reassem6 = (struct ip6_hdr*) pkt_start; reassem6->ip6_plen = htons(frag_size + proto_hdr_len - 40); - const zeek::IPv6_Hdr_Chain* chain = new zeek::IPv6_Hdr_Chain(reassem6, next_proto, n); - reassembled_pkt = new zeek::IP_Hdr(reassem6, true, n, chain); + const IPv6_Hdr_Chain* chain = new IPv6_Hdr_Chain(reassem6, next_proto, n); + reassembled_pkt = new IP_Hdr(reassem6, true, n, chain); DeleteTimer(); } else { - zeek::reporter->InternalWarning("bad IP version in fragment reassembly: %d", + reporter->InternalWarning("bad IP version in fragment reassembly: %d", version); delete [] pkt_start; } @@ -323,7 +323,7 @@ void FragReassembler::Expire(double t) expire_timer->ClearReassembler(); expire_timer = nullptr; // timer manager will delete it - zeek::sessions->Remove(this); + sessions->Remove(this); } void FragReassembler::DeleteTimer() @@ -331,7 +331,7 @@ void FragReassembler::DeleteTimer() if ( expire_timer ) { expire_timer->ClearReassembler(); - zeek::detail::timer_mgr->Cancel(expire_timer); + timer_mgr->Cancel(expire_timer); expire_timer = nullptr; // timer manager will delete it } } diff --git a/src/Frag.h b/src/Frag.h index f2f9792956..f954b18486 100644 --- a/src/Frag.h +++ b/src/Frag.h @@ -18,21 +18,21 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(FragTimer, zeek::detail); namespace zeek::detail { -using FragReassemblerKey = std::tuple; +using FragReassemblerKey = std::tuple; class FragReassembler : public Reassembler { public: - FragReassembler(zeek::NetSessions* s, const zeek::IP_Hdr* ip, const u_char* pkt, + FragReassembler(NetSessions* s, const IP_Hdr* ip, const u_char* pkt, const FragReassemblerKey& k, double t); ~FragReassembler() override; - void AddFragment(double t, const zeek::IP_Hdr* ip, const u_char* pkt); + void AddFragment(double t, const IP_Hdr* ip, const u_char* pkt); void Expire(double t); void DeleteTimer(); void ClearTimer() { expire_timer = nullptr; } - const zeek::IP_Hdr* ReassembledPkt() { return reassembled_pkt; } + const IP_Hdr* ReassembledPkt() { return reassembled_pkt; } const FragReassemblerKey& Key() const { return key; } protected: @@ -41,8 +41,8 @@ protected: void Weird(const char* name) const; u_char* proto_hdr; - zeek::IP_Hdr* reassembled_pkt; - zeek::NetSessions* s; + IP_Hdr* reassembled_pkt; + NetSessions* s; uint64_t frag_size; // size of fully reassembled fragment FragReassemblerKey key; uint16_t next_proto; // first IPv6 fragment header's next proto field @@ -51,10 +51,10 @@ protected: FragTimer* expire_timer; }; -class FragTimer final : public zeek::detail::Timer { +class FragTimer final : public Timer { public: FragTimer(FragReassembler* arg_f, double arg_t) - : zeek::detail::Timer(arg_t, zeek::detail::TIMER_FRAG) + : Timer(arg_t, TIMER_FRAG) { f = arg_f; } ~FragTimer() override; diff --git a/src/Frame.cc b/src/Frame.cc index 3575d38e51..67a42c0163 100644 --- a/src/Frame.cc +++ b/src/Frame.cc @@ -55,7 +55,7 @@ Frame::~Frame() void Frame::AddFunctionWithClosureRef(ScriptFunc* func) { - zeek::Ref(func); + Ref(func); if ( ! functions_with_closure_frame_reference ) functions_with_closure_frame_reference = std::make_unique>(); @@ -63,22 +63,22 @@ void Frame::AddFunctionWithClosureRef(ScriptFunc* func) functions_with_closure_frame_reference->emplace_back(func); } -void Frame::SetElement(int n, zeek::Val* v) - { SetElement(n, {zeek::AdoptRef{}, v}); } +void Frame::SetElement(int n, Val* v) + { SetElement(n, {AdoptRef{}, v}); } -void Frame::SetElement(int n, zeek::ValPtr v) +void Frame::SetElement(int n, ValPtr v) { ClearElement(n); frame[n] = {std::move(v), false}; } -void Frame::SetElementWeak(int n, zeek::Val* v) +void Frame::SetElementWeak(int n, Val* v) { ClearElement(n); - frame[n] = {{zeek::AdoptRef{}, v}, true}; + frame[n] = {{AdoptRef{}, v}, true}; } -void Frame::SetElement(const zeek::detail::ID* id, zeek::ValPtr v) +void Frame::SetElement(const ID* id, ValPtr v) { if ( closure ) { @@ -107,7 +107,7 @@ void Frame::SetElement(const zeek::detail::ID* id, zeek::ValPtr v) SetElement(id->Offset(), std::move(v)); } -const zeek::ValPtr& Frame::GetElementByID(const zeek::detail::ID* id) const +const ValPtr& Frame::GetElementByID(const ID* id) const { if ( closure ) { @@ -188,9 +188,9 @@ Frame* Frame::Clone() const return other; } -static bool val_is_func(const zeek::ValPtr& v, ScriptFunc* func) +static bool val_is_func(const ValPtr& v, ScriptFunc* func) { - if ( v->GetType()->Tag() != zeek::TYPE_FUNC ) + if ( v->GetType()->Tag() != TYPE_FUNC ) return false; return v->AsFunc() == func; @@ -245,7 +245,7 @@ Frame* Frame::SelectiveClone(const IDPList& selection, ScriptFunc* func) const } if ( ! frame[id->Offset()].val ) - zeek::reporter->InternalError("Attempted to clone an id ('%s') with no associated value.", id->Name()); + reporter->InternalError("Attempted to clone an id ('%s') with no associated value.", id->Name()); CloneNonFuncElement(id->Offset(), func, other); } @@ -308,7 +308,7 @@ broker::expected Frame::Serialize(const Frame* target, const IDPLi if ( them.length() ) { if ( ! target->closure ) - zeek::reporter->InternalError("Attempting to serialize values from a frame that does not exist."); + reporter->InternalError("Attempting to serialize values from a frame that does not exist."); rval.emplace_back(std::string("ClosureFrame")); @@ -348,9 +348,9 @@ broker::expected Frame::Serialize(const Frame* target, const IDPLi const auto& val = target->frame[location].val; - zeek::TypeTag tag = val->GetType()->Tag(); + TypeTag tag = val->GetType()->Tag(); - auto expected = zeek::Broker::detail::val_to_data(val.get()); + auto expected = Broker::detail::val_to_data(val.get()); if ( ! expected ) return broker::ec::invalid_data; @@ -452,7 +452,7 @@ std::pair Frame::Unserialize(const broker::vector& data) int frame_size = body.size(); // We'll associate this frame with a function later. - auto rf = zeek::make_intrusive(frame_size, nullptr, nullptr); + auto rf = make_intrusive(frame_size, nullptr, nullptr); rf->offset_map = std::make_unique(std::move(offset_map)); // Frame takes ownership of unref'ing elements in outer_ids @@ -475,9 +475,9 @@ std::pair Frame::Unserialize(const broker::vector& data) return std::make_pair(false, nullptr); broker::integer g = *has_type; - zeek::Type t( static_cast(g) ); + Type t( static_cast(g) ); - auto val = zeek::Broker::detail::data_to_val(std::move(val_tuple[0]), &t); + auto val = Broker::detail::data_to_val(std::move(val_tuple[0]), &t); if ( ! val ) return std::make_pair(false, nullptr); @@ -493,7 +493,7 @@ void Frame::AddKnownOffsets(const IDPList& ids) offset_map = std::make_unique(); std::transform(ids.begin(), ids.end(), std::inserter(*offset_map, offset_map->end()), - [] (const zeek::detail::ID* id) -> std::pair + [] (const ID* id) -> std::pair { return std::make_pair(std::string(id->Name()), id->Offset()); }); @@ -502,12 +502,12 @@ void Frame::AddKnownOffsets(const IDPList& ids) void Frame::CaptureClosure(Frame* c, IDPList arg_outer_ids) { if ( closure || outer_ids.length() ) - zeek::reporter->InternalError("Attempted to override a closure."); + reporter->InternalError("Attempted to override a closure."); outer_ids = std::move(arg_outer_ids); for ( auto& i : outer_ids ) - zeek::Ref(i); + Ref(i); closure = c; if ( closure ) @@ -520,7 +520,7 @@ void Frame::CaptureClosure(Frame* c, IDPList arg_outer_ids) // if (c) closure = c->SelectiveClone(outer_ids); } -void Frame::SetTrigger(zeek::detail::trigger::TriggerPtr arg_trigger) +void Frame::SetTrigger(trigger::TriggerPtr arg_trigger) { trigger = std::move(arg_trigger); } @@ -538,10 +538,10 @@ void Frame::ClearElement(int n) frame[n] = {nullptr, false}; } -bool Frame::IsOuterID(const zeek::detail::ID* in) const +bool Frame::IsOuterID(const ID* in) const { return std::any_of(outer_ids.begin(), outer_ids.end(), - [&in](zeek::detail::ID* id)-> bool { return strcmp(id->Name(), in->Name()) == 0; }); + [&in](ID* id)-> bool { return strcmp(id->Name(), in->Name()) == 0; }); } broker::expected Frame::SerializeIDList(const IDPList& in) @@ -603,7 +603,7 @@ Frame::UnserializeIDList(const broker::vector& data) return std::make_pair(false, std::move(rval)); } - auto* id = new zeek::detail::ID(has_name->c_str(), zeek::detail::SCOPE_FUNCTION, false); + auto* id = new ID(has_name->c_str(), SCOPE_FUNCTION, false); id->SetOffset(*has_offset); rval.push_back(id); std::advance(where, 1); diff --git a/src/Frame.h b/src/Frame.h index 56e052a13b..6dbe069d2e 100644 --- a/src/Frame.h +++ b/src/Frame.h @@ -23,17 +23,17 @@ namespace zeek::detail { class ScriptFunc; } using BroFunc [[deprecated("Remove in v4.1. Use zeek::detail::ScriptFunc instead.")]] = zeek::detail::ScriptFunc; namespace zeek { -using ValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; namespace detail { -using IDPtr = zeek::IntrusivePtr; +using IDPtr = IntrusivePtr; namespace trigger { -using TriggerPtr = zeek::IntrusivePtr; +using TriggerPtr = IntrusivePtr; } class Frame; -using FramePtr = zeek::IntrusivePtr; +using FramePtr = IntrusivePtr; class Frame : public Obj { public: @@ -57,21 +57,21 @@ public: * @param n the index to get. * @return the value at index *n* of the underlying array. */ - const zeek::ValPtr& GetElement(int n) const + const ValPtr& GetElement(int n) const { return frame[n].val; } [[deprecated("Remove in v4.1. Use GetElement(int).")]] - zeek::Val* NthElement(int n) const { return frame[n].val.get(); } + Val* NthElement(int n) const { return frame[n].val.get(); } /** * Sets the element at index *n* of the underlying array to *v*. * @param n the index to set * @param v the value to set it to */ - void SetElement(int n, zeek::ValPtr v); + void SetElement(int n, ValPtr v); [[deprecated("Remove in v4.1. Pass IntrusivePtr instead.")]] - void SetElement(int n, zeek::Val* v); + void SetElement(int n, Val* v); /** * Associates *id* and *v* in the frame. Future lookups of @@ -80,8 +80,8 @@ public: * @param id the ID to associate * @param v the value to associate it with */ - void SetElement(const zeek::detail::ID* id, zeek::ValPtr v); - void SetElement(const zeek::detail::IDPtr& id, zeek::ValPtr v) + void SetElement(const ID* id, ValPtr v); + void SetElement(const IDPtr& id, ValPtr v) { SetElement(id.get(), std::move(v)); } /** @@ -91,11 +91,11 @@ public: * @param id the id who's value to retreive * @return the value associated with *id* */ - const zeek::ValPtr& GetElementByID(const zeek::detail::IDPtr& id) const + const ValPtr& GetElementByID(const IDPtr& id) const { return GetElementByID(id.get()); } [[deprecated("Remove in v4.1. Use GetElementByID().")]] - zeek::Val* GetElement(const zeek::detail::ID* id) const + Val* GetElement(const ID* id) const { return GetElementByID(id).get(); } /** @@ -119,7 +119,7 @@ public: * @return the arguments passed to the function that this frame * is associated with. */ - const zeek::Args* GetFuncArgs() const { return func_args; } + const Args* GetFuncArgs() const { return func_args; } /** * Change the function that the frame is associated with. @@ -133,12 +133,12 @@ public: * * @param stmt the statement to set it to. */ - void SetNextStmt(zeek::detail::Stmt* stmt) { next_stmt = stmt; } + void SetNextStmt(Stmt* stmt) { next_stmt = stmt; } /** * @return the next statement to be executed in the context of the frame. */ - zeek::detail::Stmt* GetNextStmt() const { return next_stmt; } + Stmt* GetNextStmt() const { return next_stmt; } /** Used to implement "next" command in debugger. */ void BreakBeforeNextStmt(bool should_break) @@ -230,13 +230,13 @@ public: // If the frame is run in the context of a trigger condition evaluation, // the trigger needs to be registered. - void SetTrigger(zeek::detail::trigger::TriggerPtr arg_trigger); + void SetTrigger(trigger::TriggerPtr arg_trigger); void ClearTrigger(); - zeek::detail::trigger::Trigger* GetTrigger() const { return trigger.get(); } + trigger::Trigger* GetTrigger() const { return trigger.get(); } - void SetCall(const zeek::detail::CallExpr* arg_call) { call = arg_call; } + void SetCall(const CallExpr* arg_call) { call = arg_call; } void ClearCall() { call = nullptr; } - const zeek::detail::CallExpr* GetCall() const { return call; } + const CallExpr* GetCall() const { return call; } void SetDelayed() { delayed = true; } bool HasDelayed() const { return delayed; } @@ -255,13 +255,13 @@ private: using OffsetMap = std::unordered_map; struct Element { - zeek::ValPtr val; + ValPtr val; // Weak reference is used to prevent circular reference memory leaks // in lambdas/closures. bool weak_ref; }; - const zeek::ValPtr& GetElementByID(const zeek::detail::ID* id) const; + const ValPtr& GetElementByID(const ID* id) const; /** * Sets the element at index *n* of the underlying array to *v*, but does @@ -271,7 +271,7 @@ private: * @param v the value to set it to (caller has not Ref'd and Frame will * not Unref it) */ - void SetElementWeak(int n, zeek::Val* v); + void SetElementWeak(int n, Val* v); /** * Clone an element at an offset into other frame if not equal to a given @@ -287,7 +287,7 @@ private: void ClearElement(int n); /** Have we captured this id? */ - bool IsOuterID(const zeek::detail::ID* in) const; + bool IsOuterID(const ID* in) const; /** Serializes an offset_map */ static broker::expected @@ -334,10 +334,10 @@ private: const zeek::Args* func_args; /** The next statement to be evaluted in the context of this frame. */ - zeek::detail::Stmt* next_stmt; + Stmt* next_stmt; - zeek::detail::trigger::TriggerPtr trigger; - const zeek::detail::CallExpr* call; + trigger::TriggerPtr trigger; + const CallExpr* call; std::unique_ptr> functions_with_closure_frame_reference; }; diff --git a/src/Func.cc b/src/Func.cc index 79735c6506..0ea206e83c 100644 --- a/src/Func.cc +++ b/src/Func.cc @@ -108,12 +108,12 @@ std::string render_call_stack() arg_desc += d.Description(); } - rval += zeek::util::fmt("#%d %s(%s)", lvl, name, arg_desc.data()); + rval += util::fmt("#%d %s(%s)", lvl, name, arg_desc.data()); if ( ci.call ) { auto loc = ci.call->GetLocationInfo(); - rval += zeek::util::fmt(" at %s:%d", loc->filename, loc->first_line); + rval += util::fmt(" at %s:%d", loc->filename, loc->first_line); } ++lvl; @@ -128,37 +128,37 @@ std::string render_call_stack() Func::Func() { unique_id = unique_ids.size(); - unique_ids.push_back({zeek::NewRef{}, this}); + unique_ids.push_back({NewRef{}, this}); } Func::Func(Kind arg_kind) : kind(arg_kind) { unique_id = unique_ids.size(); - unique_ids.push_back({zeek::NewRef{}, this}); + unique_ids.push_back({NewRef{}, this}); } Func::~Func() = default; -void Func::AddBody(zeek::detail::StmtPtr /* new_body */, - const std::vector& /* new_inits */, +void Func::AddBody(detail::StmtPtr /* new_body */, + const std::vector& /* new_inits */, size_t /* new_frame_size */, int /* priority */) { Internal("Func::AddBody called"); } -void Func::SetScope(zeek::detail::ScopePtr newscope) +void Func::SetScope(detail::ScopePtr newscope) { scope = std::move(newscope); } -zeek::FuncPtr Func::DoClone() +FuncPtr Func::DoClone() { // By default, ok just to return a reference. Func does not have any state // that is different across instances. - return {zeek::NewRef{}, this}; + return {NewRef{}, this}; } -void Func::DescribeDebug(ODesc* d, const zeek::Args* args) const +void Func::DescribeDebug(ODesc* d, const Args* args) const { d->Add(Name()); @@ -196,7 +196,7 @@ void Func::DescribeDebug(ODesc* d, const zeek::Args* args) const detail::TraversalCode Func::Traverse(detail::TraversalCallback* cb) const { // FIXME: Make a fake scope for builtins? - zeek::detail::Scope* old_scope = cb->current_scope; + detail::Scope* old_scope = cb->current_scope; cb->current_scope = scope.get(); detail::TraversalCode tc = cb->PreFunction(this); @@ -233,8 +233,8 @@ void Func::CopyStateInto(Func* other) const other->unique_id = unique_id; } -void Func::CheckPluginResult(bool handled, const zeek::ValPtr& hook_result, - zeek::FunctionFlavor flavor) const +void Func::CheckPluginResult(bool handled, const ValPtr& hook_result, + FunctionFlavor flavor) const { // Helper function factoring out this code from ScriptFunc:Call() for // better readability. @@ -242,7 +242,7 @@ void Func::CheckPluginResult(bool handled, const zeek::ValPtr& hook_result, if ( ! handled ) { if ( hook_result ) - zeek::reporter->InternalError("plugin set processed flag to false but actually returned a value"); + reporter->InternalError("plugin set processed flag to false but actually returned a value"); // The plugin result hasn't been processed yet (read: fall // into ::Call method). @@ -250,34 +250,34 @@ void Func::CheckPluginResult(bool handled, const zeek::ValPtr& hook_result, } switch ( flavor ) { - case zeek::FUNC_FLAVOR_EVENT: + case FUNC_FLAVOR_EVENT: if ( hook_result ) - zeek::reporter->InternalError("plugin returned non-void result for event %s", + reporter->InternalError("plugin returned non-void result for event %s", this->Name()); break; - case zeek::FUNC_FLAVOR_HOOK: - if ( hook_result->GetType()->Tag() != zeek::TYPE_BOOL ) - zeek::reporter->InternalError("plugin returned non-bool for hook %s", + case FUNC_FLAVOR_HOOK: + if ( hook_result->GetType()->Tag() != TYPE_BOOL ) + reporter->InternalError("plugin returned non-bool for hook %s", this->Name()); break; - case zeek::FUNC_FLAVOR_FUNCTION: + case FUNC_FLAVOR_FUNCTION: { const auto& yt = GetType()->Yield(); - if ( (! yt) || yt->Tag() == zeek::TYPE_VOID ) + if ( (! yt) || yt->Tag() == TYPE_VOID ) { if ( hook_result ) - zeek::reporter->InternalError("plugin returned non-void result for void method %s", + reporter->InternalError("plugin returned non-void result for void method %s", this->Name()); } - else if ( hook_result && hook_result->GetType()->Tag() != yt->Tag() && yt->Tag() != zeek::TYPE_ANY ) + else if ( hook_result && hook_result->GetType()->Tag() != yt->Tag() && yt->Tag() != TYPE_ANY ) { - zeek::reporter->InternalError("plugin returned wrong type (got %d, expecting %d) for %s", + reporter->InternalError("plugin returned wrong type (got %d, expecting %d) for %s", hook_result->GetType()->Tag(), yt->Tag(), this->Name()); } @@ -286,16 +286,16 @@ void Func::CheckPluginResult(bool handled, const zeek::ValPtr& hook_result, } } -zeek::Val* Func::Call(ValPList* args, zeek::detail::Frame* parent) const +Val* Func::Call(ValPList* args, detail::Frame* parent) const { - auto zargs = zeek::val_list_to_args(*args); + auto zargs = val_list_to_args(*args); return Invoke(&zargs, parent).release(); }; namespace detail { -ScriptFunc::ScriptFunc(const zeek::detail::IDPtr& arg_id, zeek::detail::StmtPtr arg_body, - const std::vector& aggr_inits, +ScriptFunc::ScriptFunc(const IDPtr& arg_id, StmtPtr arg_body, + const std::vector& aggr_inits, size_t arg_frame_size, int priority) : Func(SCRIPT_FUNC) { @@ -324,7 +324,7 @@ bool ScriptFunc::IsPure() const [](const Body& b) { return b.stmts->IsPure(); }); } -zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) const +ValPtr ScriptFunc::Invoke(zeek::Args* args, Frame* parent) const { #ifdef PROFILE_BRO_FUNCTIONS DEBUG_MSG("Function: %s\n", Name()); @@ -346,11 +346,11 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c if ( bodies.empty() ) { // Can only happen for events and hooks. - assert(Flavor() == zeek::FUNC_FLAVOR_EVENT || Flavor() == zeek::FUNC_FLAVOR_HOOK); - return Flavor() == zeek::FUNC_FLAVOR_HOOK ? zeek::val_mgr->True() : nullptr; + assert(Flavor() == FUNC_FLAVOR_EVENT || Flavor() == FUNC_FLAVOR_HOOK); + return Flavor() == FUNC_FLAVOR_HOOK ? val_mgr->True() : nullptr; } - auto f = zeek::make_intrusive(frame_size, this, args); + auto f = make_intrusive(frame_size, this, args); if ( closure ) f->CaptureClosure(closure, outer_ids); @@ -358,12 +358,12 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c // Hand down any trigger. if ( parent ) { - f->SetTrigger({zeek::NewRef{}, parent->GetTrigger()}); + f->SetTrigger({NewRef{}, parent->GetTrigger()}); f->SetCall(parent->GetCall()); } g_frame_stack.push_back(f.get()); // used for backtracing - const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr; + const CallExpr* call_expr = parent ? parent->GetCall() : nullptr; call_stack.emplace_back(CallInfo{call_expr, this, *args}); if ( g_trace_state.DoTrace() ) @@ -376,7 +376,7 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c } StmtFlowType flow = FLOW_NEXT; - zeek::ValPtr result; + ValPtr result; for ( const auto& body : bodies ) { @@ -404,7 +404,7 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c catch ( InterpreterException& e ) { // Already reported, but now determine whether to unwind further. - if ( Flavor() == zeek::FUNC_FLAVOR_FUNCTION ) + if ( Flavor() == FUNC_FLAVOR_FUNCTION ) { g_frame_stack.pop_back(); call_stack.pop_back(); @@ -424,7 +424,7 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c break; } - if ( Flavor() == zeek::FUNC_FLAVOR_HOOK ) + if ( Flavor() == FUNC_FLAVOR_HOOK ) { // Ignore any return values of hook bodies, final return value // depends on whether a body returns as a result of break statement. @@ -433,7 +433,7 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c if ( flow == FLOW_BREAK ) { // Short-circuit execution of remaining hook handler bodies. - result = zeek::val_mgr->False(); + result = val_mgr->False(); break; } } @@ -441,19 +441,19 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c call_stack.pop_back(); - if ( Flavor() == zeek::FUNC_FLAVOR_HOOK ) + if ( Flavor() == FUNC_FLAVOR_HOOK ) { if ( ! result ) - result = zeek::val_mgr->True(); + result = val_mgr->True(); } // Warn if the function returns something, but we returned from // the function without an explicit return, or without a value. - else if ( GetType()->Yield() && GetType()->Yield()->Tag() != zeek::TYPE_VOID && + else if ( GetType()->Yield() && GetType()->Yield()->Tag() != TYPE_VOID && (flow != FLOW_RETURN /* we fell off the end */ || ! result /* explicit return with no result */) && ! f->HasDelayed() ) - zeek::reporter->Warning("non-void function returning without a value: %s", + reporter->Warning("non-void function returning without a value: %s", Name()); if ( result && g_trace_state.DoTrace() ) @@ -469,8 +469,8 @@ zeek::ValPtr ScriptFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) c return result; } -void ScriptFunc::AddBody(zeek::detail::StmtPtr new_body, - const std::vector& new_inits, +void ScriptFunc::AddBody(StmtPtr new_body, + const std::vector& new_inits, size_t new_frame_size, int priority) { if ( new_frame_size > frame_size ) @@ -483,7 +483,7 @@ void ScriptFunc::AddBody(zeek::detail::StmtPtr new_body, new_body = AddInits(std::move(new_body), new_inits); - if ( Flavor() == zeek::FUNC_FLAVOR_FUNCTION ) + if ( Flavor() == FUNC_FLAVOR_FUNCTION ) { // For functions, we replace the old body with the new one. assert(bodies.size() <= 1); @@ -498,7 +498,7 @@ void ScriptFunc::AddBody(zeek::detail::StmtPtr new_body, sort(bodies.begin(), bodies.end()); } -void ScriptFunc::AddClosure(IDPList ids, zeek::detail::Frame* f) +void ScriptFunc::AddClosure(IDPList ids, Frame* f) { if ( ! f ) return; @@ -507,7 +507,7 @@ void ScriptFunc::AddClosure(IDPList ids, zeek::detail::Frame* f) SetClosureFrame(f); } -bool ScriptFunc::StrengthenClosureReference(zeek::detail::Frame* f) +bool ScriptFunc::StrengthenClosureReference(Frame* f) { if ( closure != f ) return false; @@ -520,10 +520,10 @@ bool ScriptFunc::StrengthenClosureReference(zeek::detail::Frame* f) return true; } -void ScriptFunc::SetClosureFrame(zeek::detail::Frame* f) +void ScriptFunc::SetClosureFrame(Frame* f) { if ( closure ) - zeek::reporter->InternalError("Tried to override closure for ScriptFunc %s.", + reporter->InternalError("Tried to override closure for ScriptFunc %s.", Name()); // Have to use weak references initially because otherwise Ref'ing the @@ -540,7 +540,7 @@ void ScriptFunc::SetClosureFrame(zeek::detail::Frame* f) bool ScriptFunc::UpdateClosure(const broker::vector& data) { - auto result = zeek::detail::Frame::Unserialize(data); + auto result = Frame::Unserialize(data); if ( ! result.first ) return false; @@ -560,11 +560,11 @@ bool ScriptFunc::UpdateClosure(const broker::vector& data) } -zeek::FuncPtr ScriptFunc::DoClone() +FuncPtr ScriptFunc::DoClone() { // ScriptFunc could hold a closure. In this case a clone of it must // store a copy of this closure. - auto other = zeek::IntrusivePtr{zeek::AdoptRef{}, new ScriptFunc()}; + auto other = IntrusivePtr{AdoptRef{}, new ScriptFunc()}; CopyStateInto(other.get()); @@ -578,7 +578,7 @@ zeek::FuncPtr ScriptFunc::DoClone() broker::expected ScriptFunc::SerializeClosure() const { - return zeek::detail::Frame::Serialize(closure, outer_ids); + return Frame::Serialize(closure, outer_ids); } void ScriptFunc::Describe(ODesc* d) const @@ -594,15 +594,15 @@ void ScriptFunc::Describe(ODesc* d) const } } -zeek::detail::StmtPtr ScriptFunc::AddInits( - zeek::detail::StmtPtr body, - const std::vector& inits) +StmtPtr ScriptFunc::AddInits( + StmtPtr body, + const std::vector& inits) { if ( inits.empty() ) return body; - auto stmt_series = zeek::make_intrusive(); - stmt_series->Stmts().push_back(new zeek::detail::InitStmt(inits)); + auto stmt_series = make_intrusive(); + stmt_series->Stmts().push_back(new InitStmt(inits)); stmt_series->Stmts().push_back(body.release()); return stmt_series; @@ -616,14 +616,14 @@ BuiltinFunc::BuiltinFunc(built_in_func arg_func, const char* arg_name, name = make_full_var_name(GLOBAL_MODULE_NAME, arg_name); is_pure = arg_is_pure; - const auto& id = zeek::detail::lookup_ID(Name(), GLOBAL_MODULE_NAME, false); + const auto& id = lookup_ID(Name(), GLOBAL_MODULE_NAME, false); if ( ! id ) - zeek::reporter->InternalError("built-in function %s missing", Name()); + reporter->InternalError("built-in function %s missing", Name()); if ( id->HasVal() ) - zeek::reporter->InternalError("built-in function %s multiply defined", Name()); + reporter->InternalError("built-in function %s multiply defined", Name()); - type = id->GetType(); - id->SetVal(zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, this})); + type = id->GetType(); + id->SetVal(make_intrusive(IntrusivePtr{NewRef{}, this})); } BuiltinFunc::~BuiltinFunc() @@ -635,7 +635,7 @@ bool BuiltinFunc::IsPure() const return is_pure; } -zeek::ValPtr BuiltinFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) const +ValPtr BuiltinFunc::Invoke(Args* args, Frame* parent) const { #ifdef PROFILE_BRO_FUNCTIONS DEBUG_MSG("Function: %s\n", Name()); @@ -649,7 +649,7 @@ zeek::ValPtr BuiltinFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) HookCallFunction(this, parent, args), empty_hook_result); - CheckPluginResult(handled, hook_result, zeek::FUNC_FLAVOR_FUNCTION); + CheckPluginResult(handled, hook_result, FUNC_FLAVOR_FUNCTION); if ( handled ) return hook_result; @@ -662,7 +662,7 @@ zeek::ValPtr BuiltinFunc::Invoke(zeek::Args* args, zeek::detail::Frame* parent) g_trace_state.LogTrace("\tBuiltin Function called: %s\n", d.Description()); } - const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr; + const CallExpr* call_expr = parent ? parent->GetCall() : nullptr; call_stack.emplace_back(CallInfo{call_expr, this, *args}); auto result = std::move(func(parent, args).rval); call_stack.pop_back(); @@ -684,9 +684,9 @@ void BuiltinFunc::Describe(ODesc* d) const d->AddCount(is_pure); } -bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call) +bool check_built_in_call(BuiltinFunc* f, CallExpr* call) { - if ( f->TheFunc() != zeek::BifFunc::fmt_bif) + if ( f->TheFunc() != BifFunc::fmt_bif) return true; const ExprPList& args = call->Args()->Exprs(); @@ -697,10 +697,10 @@ bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call) return true; } - const zeek::detail::Expr* fmt_str_arg = args[0]; - if ( fmt_str_arg->GetType()->Tag() != zeek::TYPE_STRING ) + const Expr* fmt_str_arg = args[0]; + if ( fmt_str_arg->GetType()->Tag() != TYPE_STRING ) { - call->Error("first argument to zeek::util::fmt() needs to be a format string"); + call->Error("first argument to util::fmt() needs to be a format string"); return false; } @@ -729,7 +729,7 @@ bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call) if ( args.length() != num_fmt + 1 ) { - call->Error("mismatch between format string to zeek::util::fmt() and number of arguments passed"); + call->Error("mismatch between format string to util::fmt() and number of arguments passed"); return false; } } @@ -739,16 +739,16 @@ bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call) // Gets a function's priority from its Scope's attributes. Errors if it sees any // problems. -static int get_func_priority(const std::vector& attrs) +static int get_func_priority(const std::vector& attrs) { int priority = 0; for ( const auto& a : attrs ) { - if ( a->Tag() == zeek::detail::ATTR_DEPRECATED ) + if ( a->Tag() == ATTR_DEPRECATED ) continue; - if ( a->Tag() != zeek::detail::ATTR_PRIORITY ) + if ( a->Tag() != ATTR_PRIORITY ) { a->Error("illegal attribute for function body"); continue; @@ -762,7 +762,7 @@ static int get_func_priority(const std::vector& attrs) continue; } - if ( ! zeek::IsIntegral(v->GetType()->Tag()) ) + if ( ! IsIntegral(v->GetType()->Tag()) ) { a->Error("expression is not of integral type"); continue; @@ -774,7 +774,7 @@ static int get_func_priority(const std::vector& attrs) return priority; } -function_ingredients::function_ingredients(zeek::detail::ScopePtr scope, zeek::detail::StmtPtr body) +function_ingredients::function_ingredients(ScopePtr scope, StmtPtr body) { frame_size = scope->Length(); inits = scope->GetInits(); @@ -790,7 +790,7 @@ function_ingredients::function_ingredients(zeek::detail::ScopePtr scope, zeek::d static void emit_builtin_error_common(const char* msg, Obj* arg, bool unwind) { - auto emit = [=](const zeek::detail::CallExpr* ce) + auto emit = [=](const CallExpr* ce) { if ( ce ) { @@ -800,11 +800,11 @@ static void emit_builtin_error_common(const char* msg, Obj* arg, bool unwind) { ODesc d; arg->Describe(&d); - zeek::reporter->ExprRuntimeError(ce, "%s (%s), during call:", msg, + reporter->ExprRuntimeError(ce, "%s (%s), during call:", msg, d.Description()); } else - zeek::reporter->ExprRuntimeError(ce, "%s", msg); + reporter->ExprRuntimeError(ce, "%s", msg); } else ce->Error(msg, arg); @@ -814,22 +814,22 @@ static void emit_builtin_error_common(const char* msg, Obj* arg, bool unwind) if ( arg ) { if ( unwind ) - zeek::reporter->RuntimeError(arg->GetLocationInfo(), "%s", msg); + reporter->RuntimeError(arg->GetLocationInfo(), "%s", msg); else arg->Error(msg); } else { if ( unwind ) - zeek::reporter->RuntimeError(nullptr, "%s", msg); + reporter->RuntimeError(nullptr, "%s", msg); else - zeek::reporter->Error("%s", msg); + reporter->Error("%s", msg); } } }; - if ( zeek::detail::call_stack.empty() ) + if ( call_stack.empty() ) { // Shouldn't happen unless someone (mistakenly) calls builtin_error() // from somewhere that's not even evaluating script-code. @@ -837,9 +837,9 @@ static void emit_builtin_error_common(const char* msg, Obj* arg, bool unwind) return; } - auto last_call = zeek::detail::call_stack.back(); + auto last_call = call_stack.back(); - if ( zeek::detail::call_stack.size() < 2 ) + if ( call_stack.size() < 2 ) { // Don't need to check for wrapper function like "::__" emit(last_call.call); @@ -877,7 +877,7 @@ static void emit_builtin_error_common(const char* msg, Obj* arg, bool unwind) wrapper_func = module_name + "::" + func_name.substr(2); } - auto parent_call = zeek::detail::call_stack[zeek::detail::call_stack.size() - 2]; + auto parent_call = call_stack[call_stack.size() - 2]; auto parent_func = parent_call.func->Name(); if ( wrapper_func == parent_func ) @@ -891,7 +891,7 @@ void emit_builtin_exception(const char* msg) emit_builtin_error_common(msg, nullptr, true); } -void emit_builtin_exception(const char* msg, const zeek::ValPtr& arg) +void emit_builtin_exception(const char* msg, const ValPtr& arg) { emit_builtin_error_common(msg, arg.get(), true); } diff --git a/src/Func.h b/src/Func.h index 217b835776..7ac7158d60 100644 --- a/src/Func.h +++ b/src/Func.h @@ -25,12 +25,6 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail); ZEEK_FORWARD_DECLARE_NAMESPACED(FuncType, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(Frame, zeek::detail); -namespace zeek::detail { -using ScopePtr = zeek::IntrusivePtr; -using IDPtr = zeek::IntrusivePtr; -using StmtPtr = zeek::IntrusivePtr; -} - namespace caf { template class expected; } @@ -43,8 +37,16 @@ using caf::expected; namespace zeek { +namespace detail { + +using ScopePtr = IntrusivePtr; +using IDPtr = IntrusivePtr; +using StmtPtr = IntrusivePtr; + +} // namespace detail + class Func; -using FuncPtr = zeek::IntrusivePtr; +using FuncPtr = IntrusivePtr; class Func : public Obj { public: @@ -59,10 +61,10 @@ public: ~Func() override; virtual bool IsPure() const = 0; - zeek::FunctionFlavor Flavor() const { return GetType()->Flavor(); } + FunctionFlavor Flavor() const { return GetType()->Flavor(); } struct Body { - zeek::detail::StmtPtr stmts; + detail::StmtPtr stmts; int priority; bool operator<(const Body& other) const { return priority > other.priority; } // reverse sort @@ -72,7 +74,7 @@ public: bool HasBodies() const { return bodies.size(); } [[deprecated("Remove in v4.1. Use Invoke() instead.")]] - zeek::Val* Call(ValPList* args, zeek::detail::Frame* parent = nullptr) const; + Val* Call(ValPList* args, detail::Frame* parent = nullptr) const; /** * Calls a Zeek function. @@ -80,16 +82,16 @@ public: * @param parent the frame from which the function is being called. * @return the return value of the function call. */ - virtual zeek::ValPtr Invoke( - zeek::Args* args, zeek::detail::Frame* parent = nullptr) const = 0; + virtual ValPtr Invoke( + zeek::Args* args, detail::Frame* parent = nullptr) const = 0; /** * A version of Invoke() taking a variable number of individual arguments. */ template std::enable_if_t< - std::is_convertible_v>, zeek::ValPtr>, - zeek::ValPtr> + std::is_convertible_v>, ValPtr>, + ValPtr> Invoke(Args&&... args) const { auto zargs = zeek::Args{std::forward(args)...}; @@ -97,17 +99,17 @@ public: } // Add a new event handler to an existing function (event). - virtual void AddBody(zeek::detail::StmtPtr new_body, - const std::vector& new_inits, + virtual void AddBody(detail::StmtPtr new_body, + const std::vector& new_inits, size_t new_frame_size, int priority = 0); - virtual void SetScope(zeek::detail::ScopePtr newscope); - virtual zeek::detail::Scope* GetScope() const { return scope.get(); } + virtual void SetScope(detail::ScopePtr newscope); + virtual detail::Scope* GetScope() const { return scope.get(); } [[deprecated("Remove in v4.1. Use GetType().")]] - virtual zeek::FuncType* FType() const { return type.get(); } + virtual FuncType* FType() const { return type.get(); } - const zeek::FuncTypePtr& GetType() const + const FuncTypePtr& GetType() const { return type; } Kind GetKind() const { return kind; } @@ -133,30 +135,30 @@ protected: void CopyStateInto(Func* other) const; // Helper function for checking result of plugin hook. - void CheckPluginResult(bool handled, const zeek::ValPtr& hook_result, - zeek::FunctionFlavor flavor) const; + void CheckPluginResult(bool handled, const ValPtr& hook_result, + FunctionFlavor flavor) const; std::vector bodies; - zeek::detail::ScopePtr scope; + detail::ScopePtr scope; Kind kind; uint32_t unique_id; - zeek::FuncTypePtr type; + FuncTypePtr type; std::string name; static inline std::vector unique_ids; }; namespace detail { -class ScriptFunc final : public zeek::Func { +class ScriptFunc final : public Func { public: - ScriptFunc(const zeek::detail::IDPtr& id, zeek::detail::StmtPtr body, - const std::vector& inits, + ScriptFunc(const IDPtr& id, StmtPtr body, + const std::vector& inits, size_t frame_size, int priority); ~ScriptFunc() override; bool IsPure() const override; - zeek::ValPtr Invoke(zeek::Args* args, zeek::detail::Frame* parent) const override; + ValPtr Invoke(zeek::Args* args, Frame* parent) const override; /** * Adds adds a closure to the function. Closures are cloned and @@ -165,7 +167,7 @@ public: * @param ids IDs that are captured by the closure. * @param f the closure to be captured. */ - void AddClosure(IDPList ids, zeek::detail::Frame* f); + void AddClosure(IDPList ids, Frame* f); /** * Replaces the current closure with one built from *data* @@ -178,7 +180,7 @@ public: * If the function's closure is a weak reference to the given frame, * upgrade to a strong reference of a shallow clone of that frame. */ - bool StrengthenClosureReference(zeek::detail::Frame* f); + bool StrengthenClosureReference(Frame* f); /** * Serializes this function's closure. @@ -187,8 +189,8 @@ public: */ broker::expected SerializeClosure() const; - void AddBody(zeek::detail::StmtPtr new_body, - const std::vector& new_inits, + void AddBody(StmtPtr new_body, + const std::vector& new_inits, size_t new_frame_size, int priority) override; /** Sets this function's outer_id list. */ @@ -198,15 +200,15 @@ public: void Describe(ODesc* d) const override; protected: - ScriptFunc() : zeek::Func(SCRIPT_FUNC) {} - zeek::detail::StmtPtr AddInits( - zeek::detail::StmtPtr body, - const std::vector& inits); + ScriptFunc() : Func(SCRIPT_FUNC) {} + StmtPtr AddInits( + StmtPtr body, + const std::vector& inits); /** * Clones this function along with its closures. */ - zeek::FuncPtr DoClone() override; + FuncPtr DoClone() override; /** * Performs a selective clone of *f* using the IDs that were @@ -214,7 +216,7 @@ protected: * * @param f the frame to be cloned. */ - void SetClosureFrame(zeek::detail::Frame* f); + void SetClosureFrame(Frame* f); private: size_t frame_size; @@ -222,19 +224,19 @@ private: // List of the outer IDs used in the function. IDPList outer_ids; // The frame the ScriptFunc was initialized in. - zeek::detail::Frame* closure = nullptr; + Frame* closure = nullptr; bool weak_closure_ref = false; }; -using built_in_func = BifReturnVal (*)(zeek::detail::Frame* frame, const zeek::Args* args); +using built_in_func = BifReturnVal (*)(Frame* frame, const Args* args); -class BuiltinFunc final : public zeek::Func { +class BuiltinFunc final : public Func { public: BuiltinFunc(built_in_func func, const char* name, bool is_pure); ~BuiltinFunc() override; bool IsPure() const override; - zeek::ValPtr Invoke(zeek::Args* args, zeek::detail::Frame* parent) const override; + ValPtr Invoke(zeek::Args* args, Frame* parent) const override; built_in_func TheFunc() const { return func; } void Describe(ODesc* d) const override; @@ -246,10 +248,10 @@ protected: bool is_pure; }; -extern bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call); +extern bool check_built_in_call(BuiltinFunc* f, CallExpr* call); struct CallInfo { - const zeek::detail::CallExpr* call; + const CallExpr* call; const Func* func; const zeek::Args& args; }; @@ -276,7 +278,7 @@ extern std::vector call_stack; extern bool did_builtin_init; extern void emit_builtin_exception(const char* msg); -extern void emit_builtin_exception(const char* msg, const zeek::ValPtr& arg); +extern void emit_builtin_exception(const char* msg, const ValPtr& arg); extern void emit_builtin_exception(const char* msg, Obj* arg); } // namespace detail @@ -285,7 +287,7 @@ extern std::string render_call_stack(); // These methods are used by BIFs, so they're in the public namespace. extern void emit_builtin_error(const char* msg); -extern void emit_builtin_error(const char* msg, const zeek::ValPtr&); +extern void emit_builtin_error(const char* msg, const ValPtr&); extern void emit_builtin_error(const char* msg, Obj* arg); } // namespace zeek diff --git a/src/Hash.cc b/src/Hash.cc index 58541ef56d..9a80556997 100644 --- a/src/Hash.cc +++ b/src/Hash.cc @@ -46,7 +46,7 @@ void KeyedHash::InitializeSeeds(const std::array& seed void KeyedHash::InitOptions() { - calculate_digest(Hash_SHA256, zeek::BifConst::digest_salt->Bytes(), zeek::BifConst::digest_salt->Len(), reinterpret_cast(cluster_highwayhash_key)); + calculate_digest(Hash_SHA256, BifConst::digest_salt->Bytes(), BifConst::digest_salt->Len(), reinterpret_cast(cluster_highwayhash_key)); } hash64_t KeyedHash::Hash64(const void* bytes, uint64_t size) @@ -85,7 +85,7 @@ void init_hash_function() { // Make sure we have already called init_random_seed(). if ( ! KeyedHash::IsInitialized() ) - zeek::reporter->InternalError("Zeek's hash functions aren't fully initialized"); + reporter->InternalError("Zeek's hash functions aren't fully initialized"); } HashKey::HashKey(bro_int_t i) @@ -147,7 +147,7 @@ HashKey::HashKey(const char* s) hash = HashBytes(key, size); } -HashKey::HashKey(const zeek::String* s) +HashKey::HashKey(const String* s) { size = s->Len(); key = (void*) s->Bytes(); diff --git a/src/Hash.h b/src/Hash.h index b2b237a420..c2b42f9b8c 100644 --- a/src/Hash.h +++ b/src/Hash.h @@ -199,17 +199,18 @@ private: inline static uint8_t shared_hmac_md5_key[16]; inline static bool seeds_initialized = false; - friend void zeek::util::detail::hmac_md5(size_t size, const unsigned char* bytes, unsigned char digest[16]); - friend BifReturnVal zeek::BifFunc::md5_hmac_bif(zeek::detail::Frame* frame, const zeek::Args*); + friend void util::detail::hmac_md5(size_t size, const unsigned char* bytes, unsigned char digest[16]); + friend BifReturnVal BifFunc::md5_hmac_bif(zeek::detail::Frame* frame, const Args*); }; typedef enum { HASH_KEY_INT, HASH_KEY_DOUBLE, HASH_KEY_STRING -#define NUM_HASH_KEYS (int(zeek::detail::HASH_KEY_STRING) + 1) } HashKeyTag; +constexpr int NUM_HASH_KEYS = HASH_KEY_STRING + 1; + class HashKey { public: explicit HashKey(bro_int_t i); @@ -219,7 +220,7 @@ public: explicit HashKey(double d); explicit HashKey(const void* p); explicit HashKey(const char* s); - explicit HashKey(const zeek::String* s); + explicit HashKey(const String* s); ~HashKey() { if ( is_our_dynamic ) @@ -258,7 +259,7 @@ public: int Size() const { return size; } hash_t Hash() const { return hash; } - unsigned int MemoryAllocation() const { return padded_sizeof(*this) + zeek::util::pad_size(size); } + unsigned int MemoryAllocation() const { return padded_sizeof(*this) + util::pad_size(size); } static hash_t HashBytes(const void* bytes, int size); protected: diff --git a/src/ID.cc b/src/ID.cc index 46dcd50efd..5a54457b25 100644 --- a/src/ID.cc +++ b/src/ID.cc @@ -20,94 +20,96 @@ #include "zeekygen/ScriptInfo.h" #include "module_util.h" -zeek::RecordTypePtr zeek::id::conn_id; -zeek::RecordTypePtr zeek::id::endpoint; -zeek::RecordTypePtr zeek::id::connection; -zeek::RecordTypePtr zeek::id::fa_file; -zeek::RecordTypePtr zeek::id::fa_metadata; -zeek::EnumTypePtr zeek::id::transport_proto; -zeek::TableTypePtr zeek::id::string_set; -zeek::TableTypePtr zeek::id::string_array; -zeek::TableTypePtr zeek::id::count_set; -zeek::VectorTypePtr zeek::id::string_vec; -zeek::VectorTypePtr zeek::id::index_vec; +namespace zeek { -const zeek::detail::IDPtr& zeek::id::find(std::string_view name) +RecordTypePtr id::conn_id; +RecordTypePtr id::endpoint; +RecordTypePtr id::connection; +RecordTypePtr id::fa_file; +RecordTypePtr id::fa_metadata; +EnumTypePtr id::transport_proto; +TableTypePtr id::string_set; +TableTypePtr id::string_array; +TableTypePtr id::count_set; +VectorTypePtr id::string_vec; +VectorTypePtr id::index_vec; + +const detail::IDPtr& id::find(std::string_view name) { return zeek::detail::global_scope()->Find(name); } -const zeek::TypePtr& zeek::id::find_type(std::string_view name) +const TypePtr& id::find_type(std::string_view name) { auto id = zeek::detail::global_scope()->Find(name); if ( ! id ) - zeek::reporter->InternalError("Failed to find type named: %s", + reporter->InternalError("Failed to find type named: %s", std::string(name).data()); return id->GetType(); } -const zeek::ValPtr& zeek::id::find_val(std::string_view name) +const ValPtr& id::find_val(std::string_view name) { auto id = zeek::detail::global_scope()->Find(name); if ( ! id ) - zeek::reporter->InternalError("Failed to find variable named: %s", + reporter->InternalError("Failed to find variable named: %s", std::string(name).data()); return id->GetVal(); } -const zeek::ValPtr& zeek::id::find_const(std::string_view name) +const ValPtr& id::find_const(std::string_view name) { auto id = zeek::detail::global_scope()->Find(name); if ( ! id ) - zeek::reporter->InternalError("Failed to find variable named: %s", + reporter->InternalError("Failed to find variable named: %s", std::string(name).data()); if ( ! id->IsConst() ) - zeek::reporter->InternalError("Variable is not 'const', but expected to be: %s", + reporter->InternalError("Variable is not 'const', but expected to be: %s", std::string(name).data()); return id->GetVal(); } -zeek::FuncPtr zeek::id::find_func(std::string_view name) +FuncPtr id::find_func(std::string_view name) { - const auto& v = zeek::id::find_val(name); + const auto& v = id::find_val(name); if ( ! v ) return nullptr; if ( ! IsFunc(v->GetType()->Tag()) ) - zeek::reporter->InternalError("Expected variable '%s' to be a function", + reporter->InternalError("Expected variable '%s' to be a function", std::string(name).data()); return v->AsFuncPtr(); } -void zeek::id::detail::init() +void id::detail::init() { - conn_id = zeek::id::find_type("conn_id"); - endpoint = zeek::id::find_type("endpoint"); - connection = zeek::id::find_type("connection"); - fa_file = zeek::id::find_type("fa_file"); - fa_metadata = zeek::id::find_type("fa_metadata"); - transport_proto = zeek::id::find_type("transport_proto"); - string_set = zeek::id::find_type("string_set"); - string_array = zeek::id::find_type("string_array"); - count_set = zeek::id::find_type("count_set"); - string_vec = zeek::id::find_type("string_vec"); - index_vec = zeek::id::find_type("index_vec"); + conn_id = id::find_type("conn_id"); + endpoint = id::find_type("endpoint"); + connection = id::find_type("connection"); + fa_file = id::find_type("fa_file"); + fa_metadata = id::find_type("fa_metadata"); + transport_proto = id::find_type("transport_proto"); + string_set = id::find_type("string_set"); + string_array = id::find_type("string_array"); + count_set = id::find_type("count_set"); + string_vec = id::find_type("string_vec"); + index_vec = id::find_type("index_vec"); } -namespace zeek::detail { +namespace detail { ID::ID(const char* arg_name, IDScope arg_scope, bool arg_is_export) { - name = zeek::util::copy_string(arg_name); + name = util::copy_string(arg_name); scope = arg_scope; is_export = arg_is_export; is_option = false; @@ -131,7 +133,7 @@ std::string ID::ModuleName() const return extract_module_name(name); } -void ID::SetType(zeek::TypePtr t) +void ID::SetType(TypePtr t) { type = std::move(t); } @@ -146,7 +148,7 @@ void ID::ClearVal() val = nullptr; } -void ID::SetVal(zeek::ValPtr v) +void ID::SetVal(ValPtr v) { val = std::move(v); Modified(); @@ -159,12 +161,12 @@ void ID::SetVal(zeek::ValPtr v) type->Tag() == TYPE_FUNC && type->AsFuncType()->Flavor() == FUNC_FLAVOR_EVENT ) { - EventHandler* handler = zeek::event_registry->Lookup(name); + EventHandler* handler = event_registry->Lookup(name); if ( ! handler ) { handler = new EventHandler(name); handler->SetFunc(val->AsFuncPtr()); - zeek::event_registry->Register(handler); + event_registry->Register(handler); } else { @@ -175,7 +177,7 @@ void ID::SetVal(zeek::ValPtr v) } } -void ID::SetVal(zeek::ValPtr v, InitClass c) +void ID::SetVal(ValPtr v, InitClass c) { if ( c == INIT_NONE || c == INIT_FULL ) { @@ -257,7 +259,7 @@ void ID::UpdateValAttrs() const auto& attr = attrs->Find(ATTR_ERROR_HANDLER); if ( attr ) - zeek::event_registry->SetErrorHandler(Name()); + event_registry->SetErrorHandler(Name()); } if ( GetType()->Tag() == TYPE_RECORD ) @@ -267,15 +269,15 @@ void ID::UpdateValAttrs() if ( attr ) { // Apply &log to all record fields. - zeek::RecordType* rt = GetType()->AsRecordType(); + RecordType* rt = GetType()->AsRecordType(); for ( int i = 0; i < rt->NumFields(); ++i ) { TypeDecl* fd = rt->FieldDecl(i); if ( ! fd->attrs ) - fd->attrs = zeek::make_intrusive(rt->GetFieldType(i), true, IsGlobal()); + fd->attrs = make_intrusive(rt->GetFieldType(i), true, IsGlobal()); - fd->attrs->AddAttr(zeek::make_intrusive(ATTR_LOG)); + fd->attrs->AddAttr(make_intrusive(ATTR_LOG)); } } } @@ -296,8 +298,8 @@ void ID::MakeDeprecated(ExprPtr deprecation) if ( IsDeprecated() ) return; - std::vector attrv{zeek::make_intrusive(ATTR_DEPRECATED, std::move(deprecation))}; - AddAttrs(zeek::make_intrusive(std::move(attrv), GetType(), false, IsGlobal())); + std::vector attrv{make_intrusive(ATTR_DEPRECATED, std::move(deprecation))}; + AddAttrs(make_intrusive(std::move(attrv), GetType(), false, IsGlobal())); } std::string ID::GetDeprecationWarning() const @@ -309,9 +311,9 @@ std::string ID::GetDeprecationWarning() const result = depr_attr->DeprecationMessage(); if ( result.empty() ) - return zeek::util::fmt("deprecated (%s)", Name()); + return util::fmt("deprecated (%s)", Name()); else - return zeek::util::fmt("deprecated (%s): %s", Name(), result.c_str()); + return util::fmt("deprecated (%s): %s", Name(), result.c_str()); } void ID::AddAttrs(AttributesPtr a) @@ -340,18 +342,18 @@ void ID::SetOption() // option implied redefinable if ( ! IsRedefinable() ) { - std::vector attrv{zeek::make_intrusive(ATTR_REDEF)}; - AddAttrs(zeek::make_intrusive(std::move(attrv), GetType(), false, IsGlobal())); + std::vector attrv{make_intrusive(ATTR_REDEF)}; + AddAttrs(make_intrusive(std::move(attrv), GetType(), false, IsGlobal())); } } void ID::EvalFunc(ExprPtr ef, ExprPtr ev) { - auto arg1 = zeek::make_intrusive(val); - auto args = zeek::make_intrusive(); + auto arg1 = make_intrusive(val); + auto args = make_intrusive(); args->Append(std::move(arg1)); args->Append(std::move(ev)); - auto ce = zeek::make_intrusive(std::move(ef), std::move(args)); + auto ce = make_intrusive(std::move(ef), std::move(args)); SetVal(ce->Eval(nullptr)); } @@ -371,7 +373,7 @@ TraversalCode ID::Traverse(TraversalCallback* cb) const // FIXME: Perhaps we should be checking at other than global scope. else if ( val && IsFunc(val->GetType()->Tag()) && - cb->current_scope == zeek::detail::global_scope() ) + cb->current_scope == detail::global_scope() ) { tc = val->AsFunc()->Traverse(cb); HANDLE_TC_STMT_PRE(tc); @@ -614,10 +616,10 @@ void ID::DescribeReST(ODesc* d, bool roles_only) const ODesc expr_desc; ir->init_expr->Describe(&expr_desc); redef_str = expr_desc.Description(); - redef_str = zeek::util::strreplace(redef_str, "\n", " "); + redef_str = util::strreplace(redef_str, "\n", " "); d->Add(":Redefinition: "); - d->Add(zeek::util::fmt("from :doc:`/scripts/%s`", ir->from_script.data())); + d->Add(util::fmt("from :doc:`/scripts/%s`", ir->from_script.data())); d->NL(); d->PushIndent(); @@ -648,7 +650,7 @@ void ID::UpdateValID() } #endif -void ID::AddOptionHandler(zeek::FuncPtr callback, int priority) +void ID::AddOptionHandler(FuncPtr callback, int priority) { option_handlers.emplace(priority, std::move(callback)); } @@ -664,4 +666,6 @@ std::vector ID::GetOptionHandlers() const return v; } -} +} // namespace detail + +} // namespace zeek diff --git a/src/ID.h b/src/ID.h index 2ea5a41134..98e8bf0677 100644 --- a/src/ID.h +++ b/src/ID.h @@ -22,13 +22,13 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek); namespace zeek { class Type; -using TypePtr = zeek::IntrusivePtr; -using RecordTypePtr = zeek::IntrusivePtr; -using TableTypePtr = zeek::IntrusivePtr; -using VectorTypePtr = zeek::IntrusivePtr; -using EnumTypePtr = zeek::IntrusivePtr; -using ValPtr = zeek::IntrusivePtr; -using FuncPtr = zeek::IntrusivePtr; +using TypePtr = IntrusivePtr; +using RecordTypePtr = IntrusivePtr; +using TableTypePtr = IntrusivePtr; +using VectorTypePtr = IntrusivePtr; +using EnumTypePtr = IntrusivePtr; +using ValPtr = IntrusivePtr; +using FuncPtr = IntrusivePtr; } using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type; @@ -37,15 +37,15 @@ namespace zeek::detail { class Attributes; class Expr; -using ExprPtr = zeek::IntrusivePtr; +using ExprPtr = IntrusivePtr; enum InitClass { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, }; enum IDScope { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL }; class ID; -using IDPtr = zeek::IntrusivePtr; +using IDPtr = IntrusivePtr; -class ID final : public Obj, public zeek::notifier::detail::Modifiable { +class ID final : public Obj, public notifier::detail::Modifiable { public: static inline const IDPtr nil; @@ -63,7 +63,7 @@ public: std::string ModuleName() const; - void SetType(zeek::TypePtr t); + void SetType(TypePtr t); [[deprecated("Remove in v4.1. Use version that takes IntrusivePtr.")]] void SetType(zeek::Type* t); @@ -76,8 +76,8 @@ public: { return type; } template - zeek::IntrusivePtr GetType() const - { return zeek::cast_intrusive(type); } + IntrusivePtr GetType() const + { return cast_intrusive(type); } [[deprecated("Remove in v4.1. Use IsType() and GetType().")]] zeek::Type* AsType() { return is_type ? GetType().get() : nullptr; } @@ -131,7 +131,7 @@ public: [[deprecated("Remove in 4.1. Use GetAttrs().")]] Attributes* Attrs() const { return attrs.get(); } - const AttrPtr& GetAttr(zeek::detail::AttrTag t) const; + const AttrPtr& GetAttr(AttrTag t) const; bool IsDeprecated() const; @@ -158,7 +158,7 @@ public: bool HasOptionHandlers() const { return !option_handlers.empty(); } - void AddOptionHandler(zeek::FuncPtr callback, int priority); + void AddOptionHandler(FuncPtr callback, int priority); std::vector GetOptionHandlers() const; protected: @@ -178,11 +178,11 @@ protected: ValPtr val; AttributesPtr attrs; // contains list of functions that are called when an option changes - std::multimap option_handlers; + std::multimap option_handlers; }; -} +} // namespace zeek::detail using ID [[deprecated("Remove in v4.1. Use zeek::detail::ID instead.")]] = zeek::detail::ID; @@ -211,8 +211,8 @@ const TypePtr& find_type(std::string_view name); * @return The type of the identifier. */ template -zeek::IntrusivePtr find_type(std::string_view name) - { return zeek::cast_intrusive(find_type(name)); } +IntrusivePtr find_type(std::string_view name) + { return cast_intrusive(find_type(name)); } /** * Lookup an ID by its name and return its value. A fatal occurs if the ID @@ -229,8 +229,8 @@ const ValPtr& find_val(std::string_view name); * @return The current value of the identifier. */ template -zeek::IntrusivePtr find_val(std::string_view name) - { return zeek::cast_intrusive(find_val(name)); } +IntrusivePtr find_val(std::string_view name) + { return cast_intrusive(find_val(name)); } /** * Lookup an ID by its name and return its value. A fatal occurs if the ID @@ -247,8 +247,8 @@ const ValPtr& find_const(std::string_view name); * @return The current value of the identifier. */ template -zeek::IntrusivePtr find_const(std::string_view name) - { return zeek::cast_intrusive(find_const(name)); } +IntrusivePtr find_const(std::string_view name) + { return cast_intrusive(find_const(name)); } /** * Lookup an ID by its name and return the function it references. @@ -256,7 +256,7 @@ zeek::IntrusivePtr find_const(std::string_view name) * @param name The identifier name to lookup * @return The current function value the identifier references. */ -zeek::FuncPtr find_func(std::string_view name); +FuncPtr find_func(std::string_view name); extern RecordTypePtr conn_id; extern RecordTypePtr endpoint; @@ -274,8 +274,7 @@ namespace detail { void init(); -} // namespace zeek::id::detail - +} // namespace detail } // namespace zeek::id using ID [[deprecated("Remove in v4.1 Use zeek::detail::ID instead.")]] = zeek::detail::ID; diff --git a/src/IP.cc b/src/IP.cc index 8cab761c21..3d19bbcda1 100644 --- a/src/IP.cc +++ b/src/IP.cc @@ -13,22 +13,24 @@ #include "ZeekString.h" #include "Reporter.h" -static zeek::VectorValPtr BuildOptionsVal(const u_char* data, int len) +namespace zeek { + +static VectorValPtr BuildOptionsVal(const u_char* data, int len) { - auto vv = zeek::make_intrusive(zeek::id::find_type("ip6_options")); + auto vv = make_intrusive(id::find_type("ip6_options")); while ( len > 0 ) { - static auto ip6_option_type = zeek::id::find_type("ip6_option"); + static auto ip6_option_type = id::find_type("ip6_option"); const struct ip6_opt* opt = (const struct ip6_opt*) data; - auto rv = zeek::make_intrusive(ip6_option_type); - rv->Assign(0, zeek::val_mgr->Count(opt->ip6o_type)); + auto rv = make_intrusive(ip6_option_type); + rv->Assign(0, val_mgr->Count(opt->ip6o_type)); if ( opt->ip6o_type == 0 ) { // Pad1 option - rv->Assign(1, zeek::val_mgr->Count(0)); - rv->Assign(2, zeek::val_mgr->EmptyString()); + rv->Assign(1, val_mgr->Count(0)); + rv->Assign(2, val_mgr->EmptyString()); data += sizeof(uint8_t); len -= sizeof(uint8_t); } @@ -36,9 +38,9 @@ static zeek::VectorValPtr BuildOptionsVal(const u_char* data, int len) { // PadN or other option uint16_t off = 2 * sizeof(uint8_t); - rv->Assign(1, zeek::val_mgr->Count(opt->ip6o_len)); - rv->Assign(2, zeek::make_intrusive( - new zeek::String(data + off, opt->ip6o_len, true))); + rv->Assign(1, val_mgr->Count(opt->ip6o_len)); + rv->Assign(2, make_intrusive( + new String(data + off, opt->ip6o_len, true))); data += opt->ip6o_len + off; len -= opt->ip6o_len + off; } @@ -49,39 +51,37 @@ static zeek::VectorValPtr BuildOptionsVal(const u_char* data, int len) return vv; } -namespace zeek { - -zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const +RecordValPtr IPv6_Hdr::ToVal(VectorValPtr chain) const { - zeek::RecordValPtr rv; + RecordValPtr rv; switch ( type ) { case IPPROTO_IPV6: { - static auto ip6_hdr_type = zeek::id::find_type("ip6_hdr"); - rv = zeek::make_intrusive(ip6_hdr_type); + static auto ip6_hdr_type = id::find_type("ip6_hdr"); + rv = make_intrusive(ip6_hdr_type); const struct ip6_hdr* ip6 = (const struct ip6_hdr*)data; - rv->Assign(0, zeek::val_mgr->Count((ntohl(ip6->ip6_flow) & 0x0ff00000)>>20)); - rv->Assign(1, zeek::val_mgr->Count(ntohl(ip6->ip6_flow) & 0x000fffff)); - rv->Assign(2, zeek::val_mgr->Count(ntohs(ip6->ip6_plen))); - rv->Assign(3, zeek::val_mgr->Count(ip6->ip6_nxt)); - rv->Assign(4, zeek::val_mgr->Count(ip6->ip6_hlim)); - rv->Assign(5, zeek::make_intrusive(IPAddr(ip6->ip6_src))); - rv->Assign(6, zeek::make_intrusive(IPAddr(ip6->ip6_dst))); + rv->Assign(0, val_mgr->Count((ntohl(ip6->ip6_flow) & 0x0ff00000)>>20)); + rv->Assign(1, val_mgr->Count(ntohl(ip6->ip6_flow) & 0x000fffff)); + rv->Assign(2, val_mgr->Count(ntohs(ip6->ip6_plen))); + rv->Assign(3, val_mgr->Count(ip6->ip6_nxt)); + rv->Assign(4, val_mgr->Count(ip6->ip6_hlim)); + rv->Assign(5, make_intrusive(IPAddr(ip6->ip6_src))); + rv->Assign(6, make_intrusive(IPAddr(ip6->ip6_dst))); if ( ! chain ) - chain = zeek::make_intrusive( - zeek::id::find_type("ip6_ext_hdr_chain")); + chain = make_intrusive( + id::find_type("ip6_ext_hdr_chain")); rv->Assign(7, std::move(chain)); } break; case IPPROTO_HOPOPTS: { - static auto ip6_hopopts_type = zeek::id::find_type("ip6_hopopts"); - rv = zeek::make_intrusive(ip6_hopopts_type); + static auto ip6_hopopts_type = id::find_type("ip6_hopopts"); + rv = make_intrusive(ip6_hopopts_type); const struct ip6_hbh* hbh = (const struct ip6_hbh*)data; - rv->Assign(0, zeek::val_mgr->Count(hbh->ip6h_nxt)); - rv->Assign(1, zeek::val_mgr->Count(hbh->ip6h_len)); + rv->Assign(0, val_mgr->Count(hbh->ip6h_nxt)); + rv->Assign(1, val_mgr->Count(hbh->ip6h_len)); uint16_t off = 2 * sizeof(uint8_t); rv->Assign(2, BuildOptionsVal(data + off, Length() - off)); @@ -90,11 +90,11 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case IPPROTO_DSTOPTS: { - static auto ip6_dstopts_type = zeek::id::find_type("ip6_dstopts"); - rv = zeek::make_intrusive(ip6_dstopts_type); + static auto ip6_dstopts_type = id::find_type("ip6_dstopts"); + rv = make_intrusive(ip6_dstopts_type); const struct ip6_dest* dst = (const struct ip6_dest*)data; - rv->Assign(0, zeek::val_mgr->Count(dst->ip6d_nxt)); - rv->Assign(1, zeek::val_mgr->Count(dst->ip6d_len)); + rv->Assign(0, val_mgr->Count(dst->ip6d_nxt)); + rv->Assign(1, val_mgr->Count(dst->ip6d_len)); uint16_t off = 2 * sizeof(uint8_t); rv->Assign(2, BuildOptionsVal(data + off, Length() - off)); } @@ -102,95 +102,95 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case IPPROTO_ROUTING: { - static auto ip6_routing_type = zeek::id::find_type("ip6_routing"); - rv = zeek::make_intrusive(ip6_routing_type); + static auto ip6_routing_type = id::find_type("ip6_routing"); + rv = make_intrusive(ip6_routing_type); const struct ip6_rthdr* rt = (const struct ip6_rthdr*)data; - rv->Assign(0, zeek::val_mgr->Count(rt->ip6r_nxt)); - rv->Assign(1, zeek::val_mgr->Count(rt->ip6r_len)); - rv->Assign(2, zeek::val_mgr->Count(rt->ip6r_type)); - rv->Assign(3, zeek::val_mgr->Count(rt->ip6r_segleft)); + rv->Assign(0, val_mgr->Count(rt->ip6r_nxt)); + rv->Assign(1, val_mgr->Count(rt->ip6r_len)); + rv->Assign(2, val_mgr->Count(rt->ip6r_type)); + rv->Assign(3, val_mgr->Count(rt->ip6r_segleft)); uint16_t off = 4 * sizeof(uint8_t); - rv->Assign(4, zeek::make_intrusive(new zeek::String(data + off, Length() - off, true))); + rv->Assign(4, make_intrusive(new String(data + off, Length() - off, true))); } break; case IPPROTO_FRAGMENT: { - static auto ip6_fragment_type = zeek::id::find_type("ip6_fragment"); - rv = zeek::make_intrusive(ip6_fragment_type); + static auto ip6_fragment_type = id::find_type("ip6_fragment"); + rv = make_intrusive(ip6_fragment_type); const struct ip6_frag* frag = (const struct ip6_frag*)data; - rv->Assign(0, zeek::val_mgr->Count(frag->ip6f_nxt)); - rv->Assign(1, zeek::val_mgr->Count(frag->ip6f_reserved)); - rv->Assign(2, zeek::val_mgr->Count((ntohs(frag->ip6f_offlg) & 0xfff8)>>3)); - rv->Assign(3, zeek::val_mgr->Count((ntohs(frag->ip6f_offlg) & 0x0006)>>1)); - rv->Assign(4, zeek::val_mgr->Bool(ntohs(frag->ip6f_offlg) & 0x0001)); - rv->Assign(5, zeek::val_mgr->Count(ntohl(frag->ip6f_ident))); + rv->Assign(0, val_mgr->Count(frag->ip6f_nxt)); + rv->Assign(1, val_mgr->Count(frag->ip6f_reserved)); + rv->Assign(2, val_mgr->Count((ntohs(frag->ip6f_offlg) & 0xfff8)>>3)); + rv->Assign(3, val_mgr->Count((ntohs(frag->ip6f_offlg) & 0x0006)>>1)); + rv->Assign(4, val_mgr->Bool(ntohs(frag->ip6f_offlg) & 0x0001)); + rv->Assign(5, val_mgr->Count(ntohl(frag->ip6f_ident))); } break; case IPPROTO_AH: { - static auto ip6_ah_type = zeek::id::find_type("ip6_ah"); - rv = zeek::make_intrusive(ip6_ah_type); - rv->Assign(0, zeek::val_mgr->Count(((ip6_ext*)data)->ip6e_nxt)); - rv->Assign(1, zeek::val_mgr->Count(((ip6_ext*)data)->ip6e_len)); - rv->Assign(2, zeek::val_mgr->Count(ntohs(((uint16_t*)data)[1]))); - rv->Assign(3, zeek::val_mgr->Count(ntohl(((uint32_t*)data)[1]))); + static auto ip6_ah_type = id::find_type("ip6_ah"); + rv = make_intrusive(ip6_ah_type); + rv->Assign(0, val_mgr->Count(((ip6_ext*)data)->ip6e_nxt)); + rv->Assign(1, val_mgr->Count(((ip6_ext*)data)->ip6e_len)); + rv->Assign(2, val_mgr->Count(ntohs(((uint16_t*)data)[1]))); + rv->Assign(3, val_mgr->Count(ntohl(((uint32_t*)data)[1]))); if ( Length() >= 12 ) { // Sequence Number and ICV fields can only be extracted if // Payload Len was non-zero for this header. - rv->Assign(4, zeek::val_mgr->Count(ntohl(((uint32_t*)data)[2]))); + rv->Assign(4, val_mgr->Count(ntohl(((uint32_t*)data)[2]))); uint16_t off = 3 * sizeof(uint32_t); - rv->Assign(5, zeek::make_intrusive(new zeek::String(data + off, Length() - off, true))); + rv->Assign(5, make_intrusive(new String(data + off, Length() - off, true))); } } break; case IPPROTO_ESP: { - static auto ip6_esp_type = zeek::id::find_type("ip6_esp"); - rv = zeek::make_intrusive(ip6_esp_type); + static auto ip6_esp_type = id::find_type("ip6_esp"); + rv = make_intrusive(ip6_esp_type); const uint32_t* esp = (const uint32_t*)data; - rv->Assign(0, zeek::val_mgr->Count(ntohl(esp[0]))); - rv->Assign(1, zeek::val_mgr->Count(ntohl(esp[1]))); + rv->Assign(0, val_mgr->Count(ntohl(esp[0]))); + rv->Assign(1, val_mgr->Count(ntohl(esp[1]))); } break; #ifdef ENABLE_MOBILE_IPV6 case IPPROTO_MOBILITY: { - static auto ip6_mob_type = zeek::id::find_type("ip6_mobility_hdr"); - rv = zeek::make_intrusive(ip6_mob_type); + static auto ip6_mob_type = id::find_type("ip6_mobility_hdr"); + rv = make_intrusive(ip6_mob_type); const struct ip6_mobility* mob = (const struct ip6_mobility*) data; - rv->Assign(0, zeek::val_mgr->Count(mob->ip6mob_payload)); - rv->Assign(1, zeek::val_mgr->Count(mob->ip6mob_len)); - rv->Assign(2, zeek::val_mgr->Count(mob->ip6mob_type)); - rv->Assign(3, zeek::val_mgr->Count(mob->ip6mob_rsv)); - rv->Assign(4, zeek::val_mgr->Count(ntohs(mob->ip6mob_chksum))); + rv->Assign(0, val_mgr->Count(mob->ip6mob_payload)); + rv->Assign(1, val_mgr->Count(mob->ip6mob_len)); + rv->Assign(2, val_mgr->Count(mob->ip6mob_type)); + rv->Assign(3, val_mgr->Count(mob->ip6mob_rsv)); + rv->Assign(4, val_mgr->Count(ntohs(mob->ip6mob_chksum))); - static auto ip6_mob_msg_type = zeek::id::find_type("ip6_mobility_msg"); - auto msg = zeek::make_intrusive(ip6_mob_msg_type); - msg->Assign(0, zeek::val_mgr->Count(mob->ip6mob_type)); + static auto ip6_mob_msg_type = id::find_type("ip6_mobility_msg"); + auto msg = make_intrusive(ip6_mob_msg_type); + msg->Assign(0, val_mgr->Count(mob->ip6mob_type)); uint16_t off = sizeof(ip6_mobility); const u_char* msg_data = data + off; - static auto ip6_mob_brr_type = zeek::id::find_type("ip6_mobility_brr"); - static auto ip6_mob_hoti_type = zeek::id::find_type("ip6_mobility_hoti"); - static auto ip6_mob_coti_type = zeek::id::find_type("ip6_mobility_coti"); - static auto ip6_mob_hot_type = zeek::id::find_type("ip6_mobility_hot"); - static auto ip6_mob_cot_type = zeek::id::find_type("ip6_mobility_cot"); - static auto ip6_mob_bu_type = zeek::id::find_type("ip6_mobility_bu"); - static auto ip6_mob_back_type = zeek::id::find_type("ip6_mobility_back"); - static auto ip6_mob_be_type = zeek::id::find_type("ip6_mobility_be"); + static auto ip6_mob_brr_type = id::find_type("ip6_mobility_brr"); + static auto ip6_mob_hoti_type = id::find_type("ip6_mobility_hoti"); + static auto ip6_mob_coti_type = id::find_type("ip6_mobility_coti"); + static auto ip6_mob_hot_type = id::find_type("ip6_mobility_hot"); + static auto ip6_mob_cot_type = id::find_type("ip6_mobility_cot"); + static auto ip6_mob_bu_type = id::find_type("ip6_mobility_bu"); + static auto ip6_mob_back_type = id::find_type("ip6_mobility_back"); + static auto ip6_mob_be_type = id::find_type("ip6_mobility_be"); switch ( mob->ip6mob_type ) { case 0: { - auto m = zeek::make_intrusive(ip6_mob_brr_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + auto m = make_intrusive(ip6_mob_brr_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); off += sizeof(uint16_t); m->Assign(1, BuildOptionsVal(data + off, Length() - off)); msg->Assign(1, std::move(m)); @@ -199,9 +199,9 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 1: { - auto m = zeek::make_intrusive(ip6_mob_hoti_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); - m->Assign(1, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); + auto m = make_intrusive(ip6_mob_hoti_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + m->Assign(1, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); off += sizeof(uint16_t) + sizeof(uint64_t); m->Assign(2, BuildOptionsVal(data + off, Length() - off)); msg->Assign(2, std::move(m)); @@ -210,9 +210,9 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 2: { - auto m = zeek::make_intrusive(ip6_mob_coti_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); - m->Assign(1, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); + auto m = make_intrusive(ip6_mob_coti_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + m->Assign(1, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); off += sizeof(uint16_t) + sizeof(uint64_t); m->Assign(2, BuildOptionsVal(data + off, Length() - off)); msg->Assign(3, std::move(m)); @@ -221,10 +221,10 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 3: { - auto m = zeek::make_intrusive(ip6_mob_hot_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); - m->Assign(1, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); - m->Assign(2, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t) + sizeof(uint64_t)))))); + auto m = make_intrusive(ip6_mob_hot_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + m->Assign(1, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); + m->Assign(2, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t) + sizeof(uint64_t)))))); off += sizeof(uint16_t) + 2 * sizeof(uint64_t); m->Assign(3, BuildOptionsVal(data + off, Length() - off)); msg->Assign(4, std::move(m)); @@ -233,10 +233,10 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 4: { - auto m = zeek::make_intrusive(ip6_mob_cot_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); - m->Assign(1, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); - m->Assign(2, zeek::val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t) + sizeof(uint64_t)))))); + auto m = make_intrusive(ip6_mob_cot_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + m->Assign(1, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t)))))); + m->Assign(2, val_mgr->Count(ntohll(*((uint64_t*)(msg_data + sizeof(uint16_t) + sizeof(uint64_t)))))); off += sizeof(uint16_t) + 2 * sizeof(uint64_t); m->Assign(3, BuildOptionsVal(data + off, Length() - off)); msg->Assign(5, std::move(m)); @@ -245,13 +245,13 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 5: { - auto m = zeek::make_intrusive(ip6_mob_bu_type); - m->Assign(0, zeek::val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); - m->Assign(1, zeek::val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x8000)); - m->Assign(2, zeek::val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x4000)); - m->Assign(3, zeek::val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x2000)); - m->Assign(4, zeek::val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x1000)); - m->Assign(5, zeek::val_mgr->Count(ntohs(*((uint16_t*)(msg_data + 2*sizeof(uint16_t)))))); + auto m = make_intrusive(ip6_mob_bu_type); + m->Assign(0, val_mgr->Count(ntohs(*((uint16_t*)msg_data)))); + m->Assign(1, val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x8000)); + m->Assign(2, val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x4000)); + m->Assign(3, val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x2000)); + m->Assign(4, val_mgr->Bool(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))) & 0x1000)); + m->Assign(5, val_mgr->Count(ntohs(*((uint16_t*)(msg_data + 2*sizeof(uint16_t)))))); off += 3 * sizeof(uint16_t); m->Assign(6, BuildOptionsVal(data + off, Length() - off)); msg->Assign(6, std::move(m)); @@ -260,11 +260,11 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 6: { - auto m = zeek::make_intrusive(ip6_mob_back_type); - m->Assign(0, zeek::val_mgr->Count(*((uint8_t*)msg_data))); - m->Assign(1, zeek::val_mgr->Bool(*((uint8_t*)(msg_data + sizeof(uint8_t))) & 0x80)); - m->Assign(2, zeek::val_mgr->Count(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))))); - m->Assign(3, zeek::val_mgr->Count(ntohs(*((uint16_t*)(msg_data + 2*sizeof(uint16_t)))))); + auto m = make_intrusive(ip6_mob_back_type); + m->Assign(0, val_mgr->Count(*((uint8_t*)msg_data))); + m->Assign(1, val_mgr->Bool(*((uint8_t*)(msg_data + sizeof(uint8_t))) & 0x80)); + m->Assign(2, val_mgr->Count(ntohs(*((uint16_t*)(msg_data + sizeof(uint16_t)))))); + m->Assign(3, val_mgr->Count(ntohs(*((uint16_t*)(msg_data + 2*sizeof(uint16_t)))))); off += 3 * sizeof(uint16_t); m->Assign(4, BuildOptionsVal(data + off, Length() - off)); msg->Assign(7, std::move(m)); @@ -273,10 +273,10 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const case 7: { - auto m = zeek::make_intrusive(ip6_mob_be_type); - m->Assign(0, zeek::val_mgr->Count(*((uint8_t*)msg_data))); + auto m = make_intrusive(ip6_mob_be_type); + m->Assign(0, val_mgr->Count(*((uint8_t*)msg_data))); const in6_addr* hoa = (const in6_addr*)(msg_data + sizeof(uint16_t)); - m->Assign(1, zeek::make_intrusive(IPAddr(*hoa))); + m->Assign(1, make_intrusive(IPAddr(*hoa))); off += sizeof(uint16_t) + sizeof(in6_addr); m->Assign(2, BuildOptionsVal(data + off, Length() - off)); msg->Assign(8, std::move(m)); @@ -284,7 +284,7 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const } default: - zeek::reporter->Weird("unknown_mobility_type", zeek::util::fmt("%d", mob->ip6mob_type)); + reporter->Weird("unknown_mobility_type", util::fmt("%d", mob->ip6mob_type)); break; } @@ -300,12 +300,12 @@ zeek::RecordValPtr IPv6_Hdr::ToVal(zeek::VectorValPtr chain) const return rv; } -zeek::RecordValPtr IPv6_Hdr::ToVal() const +RecordValPtr IPv6_Hdr::ToVal() const { return ToVal(nullptr); } -zeek::RecordVal* IPv6_Hdr::BuildRecordVal(zeek::VectorVal* chain) const +RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const { - return ToVal({zeek::AdoptRef{}, chain}).release(); + return ToVal({AdoptRef{}, chain}).release(); } IPAddr IP_Hdr::IPHeaderSrcAddr() const @@ -328,22 +328,22 @@ IPAddr IP_Hdr::DstAddr() const return ip4 ? IPAddr(ip4->ip_dst) : ip6_hdrs->DstAddr(); } -zeek::RecordValPtr IP_Hdr::ToIPHdrVal() const +RecordValPtr IP_Hdr::ToIPHdrVal() const { - zeek::RecordValPtr rval; + RecordValPtr rval; if ( ip4 ) { - static auto ip4_hdr_type = zeek::id::find_type("ip4_hdr"); - rval = zeek::make_intrusive(ip4_hdr_type); - rval->Assign(0, zeek::val_mgr->Count(ip4->ip_hl * 4)); - rval->Assign(1, zeek::val_mgr->Count(ip4->ip_tos)); - rval->Assign(2, zeek::val_mgr->Count(ntohs(ip4->ip_len))); - rval->Assign(3, zeek::val_mgr->Count(ntohs(ip4->ip_id))); - rval->Assign(4, zeek::val_mgr->Count(ip4->ip_ttl)); - rval->Assign(5, zeek::val_mgr->Count(ip4->ip_p)); - rval->Assign(6, zeek::make_intrusive(ip4->ip_src.s_addr)); - rval->Assign(7, zeek::make_intrusive(ip4->ip_dst.s_addr)); + static auto ip4_hdr_type = id::find_type("ip4_hdr"); + rval = make_intrusive(ip4_hdr_type); + rval->Assign(0, val_mgr->Count(ip4->ip_hl * 4)); + rval->Assign(1, val_mgr->Count(ip4->ip_tos)); + rval->Assign(2, val_mgr->Count(ntohs(ip4->ip_len))); + rval->Assign(3, val_mgr->Count(ntohs(ip4->ip_id))); + rval->Assign(4, val_mgr->Count(ip4->ip_ttl)); + rval->Assign(5, val_mgr->Count(ip4->ip_p)); + rval->Assign(6, make_intrusive(ip4->ip_src.s_addr)); + rval->Assign(7, make_intrusive(ip4->ip_dst.s_addr)); } else { @@ -353,27 +353,27 @@ zeek::RecordValPtr IP_Hdr::ToIPHdrVal() const return rval; } -zeek::RecordVal* IP_Hdr::BuildIPHdrVal() const +RecordVal* IP_Hdr::BuildIPHdrVal() const { return ToIPHdrVal().release(); } -zeek::RecordValPtr IP_Hdr::ToPktHdrVal() const +RecordValPtr IP_Hdr::ToPktHdrVal() const { - static auto pkt_hdr_type = zeek::id::find_type("pkt_hdr"); - return ToPktHdrVal(zeek::make_intrusive(pkt_hdr_type), 0); + static auto pkt_hdr_type = id::find_type("pkt_hdr"); + return ToPktHdrVal(make_intrusive(pkt_hdr_type), 0); } -zeek::RecordVal* IP_Hdr::BuildPktHdrVal() const +RecordVal* IP_Hdr::BuildPktHdrVal() const { return ToPktHdrVal().release(); } -zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) const +RecordValPtr IP_Hdr::ToPktHdrVal(RecordValPtr pkt_hdr, int sindex) const { - static auto tcp_hdr_type = zeek::id::find_type("tcp_hdr"); - static auto udp_hdr_type = zeek::id::find_type("udp_hdr"); - static auto icmp_hdr_type = zeek::id::find_type("icmp_hdr"); + static auto tcp_hdr_type = id::find_type("tcp_hdr"); + static auto udp_hdr_type = id::find_type("udp_hdr"); + static auto icmp_hdr_type = id::find_type("icmp_hdr"); if ( ip4 ) pkt_hdr->Assign(sindex + 0, ToIPHdrVal()); @@ -388,20 +388,20 @@ zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) c case IPPROTO_TCP: { const struct tcphdr* tp = (const struct tcphdr*) data; - auto tcp_hdr = zeek::make_intrusive(tcp_hdr_type); + auto tcp_hdr = make_intrusive(tcp_hdr_type); int tcp_hdr_len = tp->th_off * 4; int data_len = PayloadLen() - tcp_hdr_len; - tcp_hdr->Assign(0, zeek::val_mgr->Port(ntohs(tp->th_sport), TRANSPORT_TCP)); - tcp_hdr->Assign(1, zeek::val_mgr->Port(ntohs(tp->th_dport), TRANSPORT_TCP)); - tcp_hdr->Assign(2, zeek::val_mgr->Count(uint32_t(ntohl(tp->th_seq)))); - tcp_hdr->Assign(3, zeek::val_mgr->Count(uint32_t(ntohl(tp->th_ack)))); - tcp_hdr->Assign(4, zeek::val_mgr->Count(tcp_hdr_len)); - tcp_hdr->Assign(5, zeek::val_mgr->Count(data_len)); - tcp_hdr->Assign(6, zeek::val_mgr->Count(tp->th_x2)); - tcp_hdr->Assign(7, zeek::val_mgr->Count(tp->th_flags)); - tcp_hdr->Assign(8, zeek::val_mgr->Count(ntohs(tp->th_win))); + tcp_hdr->Assign(0, val_mgr->Port(ntohs(tp->th_sport), TRANSPORT_TCP)); + tcp_hdr->Assign(1, val_mgr->Port(ntohs(tp->th_dport), TRANSPORT_TCP)); + tcp_hdr->Assign(2, val_mgr->Count(uint32_t(ntohl(tp->th_seq)))); + tcp_hdr->Assign(3, val_mgr->Count(uint32_t(ntohl(tp->th_ack)))); + tcp_hdr->Assign(4, val_mgr->Count(tcp_hdr_len)); + tcp_hdr->Assign(5, val_mgr->Count(data_len)); + tcp_hdr->Assign(6, val_mgr->Count(tp->th_x2)); + tcp_hdr->Assign(7, val_mgr->Count(tp->th_flags)); + tcp_hdr->Assign(8, val_mgr->Count(ntohs(tp->th_win))); pkt_hdr->Assign(sindex + 2, std::move(tcp_hdr)); break; @@ -410,11 +410,11 @@ zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) c case IPPROTO_UDP: { const struct udphdr* up = (const struct udphdr*) data; - auto udp_hdr = zeek::make_intrusive(udp_hdr_type); + auto udp_hdr = make_intrusive(udp_hdr_type); - udp_hdr->Assign(0, zeek::val_mgr->Port(ntohs(up->uh_sport), TRANSPORT_UDP)); - udp_hdr->Assign(1, zeek::val_mgr->Port(ntohs(up->uh_dport), TRANSPORT_UDP)); - udp_hdr->Assign(2, zeek::val_mgr->Count(ntohs(up->uh_ulen))); + udp_hdr->Assign(0, val_mgr->Port(ntohs(up->uh_sport), TRANSPORT_UDP)); + udp_hdr->Assign(1, val_mgr->Port(ntohs(up->uh_dport), TRANSPORT_UDP)); + udp_hdr->Assign(2, val_mgr->Count(ntohs(up->uh_ulen))); pkt_hdr->Assign(sindex + 3, std::move(udp_hdr)); break; @@ -423,9 +423,9 @@ zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) c case IPPROTO_ICMP: { const struct icmp* icmpp = (const struct icmp *) data; - auto icmp_hdr = zeek::make_intrusive(icmp_hdr_type); + auto icmp_hdr = make_intrusive(icmp_hdr_type); - icmp_hdr->Assign(0, zeek::val_mgr->Count(icmpp->icmp_type)); + icmp_hdr->Assign(0, val_mgr->Count(icmpp->icmp_type)); pkt_hdr->Assign(sindex + 4, std::move(icmp_hdr)); break; @@ -434,9 +434,9 @@ zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) c case IPPROTO_ICMPV6: { const struct icmp6_hdr* icmpp = (const struct icmp6_hdr*) data; - auto icmp_hdr = zeek::make_intrusive(icmp_hdr_type); + auto icmp_hdr = make_intrusive(icmp_hdr_type); - icmp_hdr->Assign(0, zeek::val_mgr->Count(icmpp->icmp6_type)); + icmp_hdr->Assign(0, val_mgr->Count(icmpp->icmp6_type)); pkt_hdr->Assign(sindex + 4, std::move(icmp_hdr)); break; @@ -452,9 +452,9 @@ zeek::RecordValPtr IP_Hdr::ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) c return pkt_hdr; } -zeek::RecordVal* IP_Hdr::BuildPktHdrVal(zeek::RecordVal* pkt_hdr, int sindex) const +RecordVal* IP_Hdr::BuildPktHdrVal(RecordVal* pkt_hdr, int sindex) const { - return ToPktHdrVal({zeek::AdoptRef{}, pkt_hdr}, sindex).release(); + return ToPktHdrVal({AdoptRef{}, pkt_hdr}, sindex).release(); } static inline bool isIPv6ExtHeader(uint8_t type) @@ -494,7 +494,7 @@ void IPv6_Hdr_Chain::Init(const struct ip6_hdr* ip6, int total_len, if ( total_len < (int)sizeof(struct ip6_hdr) ) { - zeek::reporter->InternalWarning("truncated IP header in IPv6_HdrChain::Init"); + reporter->InternalWarning("truncated IP header in IPv6_HdrChain::Init"); return; } @@ -552,7 +552,7 @@ bool IPv6_Hdr_Chain::IsFragment() const { if ( chain.empty() ) { - zeek::reporter->InternalWarning("empty IPv6 header chain"); + reporter->InternalWarning("empty IPv6 header chain"); return false; } @@ -567,7 +567,7 @@ IPAddr IPv6_Hdr_Chain::SrcAddr() const #endif if ( chain.empty() ) { - zeek::reporter->InternalWarning("empty IPv6 header chain"); + reporter->InternalWarning("empty IPv6 header chain"); return IPAddr(); } @@ -581,7 +581,7 @@ IPAddr IPv6_Hdr_Chain::DstAddr() const if ( chain.empty() ) { - zeek::reporter->InternalWarning("empty IPv6 header chain"); + reporter->InternalWarning("empty IPv6 header chain"); return IPAddr(); } @@ -593,7 +593,7 @@ void IPv6_Hdr_Chain::ProcessRoutingHeader(const struct ip6_rthdr* r, uint16_t le if ( finalDst ) { // RFC 2460 section 4.1 says Routing should occur at most once. - zeek::reporter->Weird(SrcAddr(), DstAddr(), "multiple_routing_headers"); + reporter->Weird(SrcAddr(), DstAddr(), "multiple_routing_headers"); return; } @@ -608,11 +608,11 @@ void IPv6_Hdr_Chain::ProcessRoutingHeader(const struct ip6_rthdr* r, uint16_t le if ( r->ip6r_len % 2 == 0 ) finalDst = new IPAddr(*addr); else - zeek::reporter->Weird(SrcAddr(), DstAddr(), "odd_routing0_len"); + reporter->Weird(SrcAddr(), DstAddr(), "odd_routing0_len"); } // Always raise a weird since this type is deprecated. - zeek::reporter->Weird(SrcAddr(), DstAddr(), "routing0_hdr"); + reporter->Weird(SrcAddr(), DstAddr(), "routing0_hdr"); } break; @@ -624,15 +624,15 @@ void IPv6_Hdr_Chain::ProcessRoutingHeader(const struct ip6_rthdr* r, uint16_t le if ( r->ip6r_len == 2 ) finalDst = new IPAddr(*addr); else - zeek::reporter->Weird(SrcAddr(), DstAddr(), "bad_routing2_len"); + reporter->Weird(SrcAddr(), DstAddr(), "bad_routing2_len"); } } break; #endif default: - zeek::reporter->Weird(SrcAddr(), DstAddr(), "unknown_routing_type", - zeek::util::fmt("%d", r->ip6r_type)); + reporter->Weird(SrcAddr(), DstAddr(), "unknown_routing_type", + util::fmt("%d", r->ip6r_type)); break; } } @@ -652,11 +652,11 @@ void IPv6_Hdr_Chain::ProcessDstOpts(const struct ip6_dest* d, uint16_t len) { if ( opt->ip6o_len == 16 ) if ( homeAddr ) - zeek::reporter->Weird(SrcAddr(), DstAddr(), "multiple_home_addr_opts"); + reporter->Weird(SrcAddr(), DstAddr(), "multiple_home_addr_opts"); else homeAddr = new IPAddr(*((const in6_addr*)(data + 2))); else - zeek::reporter->Weird(SrcAddr(), DstAddr(), "bad_home_addr_len"); + reporter->Weird(SrcAddr(), DstAddr(), "bad_home_addr_len"); } break; @@ -678,24 +678,24 @@ void IPv6_Hdr_Chain::ProcessDstOpts(const struct ip6_dest* d, uint16_t len) } #endif -zeek::VectorValPtr IPv6_Hdr_Chain::ToVal() const +VectorValPtr IPv6_Hdr_Chain::ToVal() const { - static auto ip6_ext_hdr_type = zeek::id::find_type("ip6_ext_hdr"); - static auto ip6_hopopts_type = zeek::id::find_type("ip6_hopopts"); - static auto ip6_dstopts_type = zeek::id::find_type("ip6_dstopts"); - static auto ip6_routing_type = zeek::id::find_type("ip6_routing"); - static auto ip6_fragment_type = zeek::id::find_type("ip6_fragment"); - static auto ip6_ah_type = zeek::id::find_type("ip6_ah"); - static auto ip6_esp_type = zeek::id::find_type("ip6_esp"); - static auto ip6_ext_hdr_chain_type = zeek::id::find_type("ip6_ext_hdr_chain"); - auto rval = zeek::make_intrusive(ip6_ext_hdr_chain_type); + static auto ip6_ext_hdr_type = id::find_type("ip6_ext_hdr"); + static auto ip6_hopopts_type = id::find_type("ip6_hopopts"); + static auto ip6_dstopts_type = id::find_type("ip6_dstopts"); + static auto ip6_routing_type = id::find_type("ip6_routing"); + static auto ip6_fragment_type = id::find_type("ip6_fragment"); + static auto ip6_ah_type = id::find_type("ip6_ah"); + static auto ip6_esp_type = id::find_type("ip6_esp"); + static auto ip6_ext_hdr_chain_type = id::find_type("ip6_ext_hdr_chain"); + auto rval = make_intrusive(ip6_ext_hdr_chain_type); for ( size_t i = 1; i < chain.size(); ++i ) { auto v = chain[i]->ToVal(); - auto ext_hdr = zeek::make_intrusive(ip6_ext_hdr_type); + auto ext_hdr = make_intrusive(ip6_ext_hdr_type); uint8_t type = chain[i]->Type(); - ext_hdr->Assign(0, zeek::val_mgr->Count(type)); + ext_hdr->Assign(0, val_mgr->Count(type)); switch (type) { case IPPROTO_HOPOPTS: @@ -722,7 +722,7 @@ zeek::VectorValPtr IPv6_Hdr_Chain::ToVal() const break; #endif default: - zeek::reporter->InternalWarning("IPv6_Hdr_Chain bad header %d", type); + reporter->InternalWarning("IPv6_Hdr_Chain bad header %d", type); continue; } @@ -732,7 +732,7 @@ zeek::VectorValPtr IPv6_Hdr_Chain::ToVal() const return rval; } -zeek::VectorVal* IPv6_Hdr_Chain::BuildVal() const +VectorVal* IPv6_Hdr_Chain::BuildVal() const { return ToVal().release(); } @@ -768,7 +768,7 @@ IPv6_Hdr_Chain* IPv6_Hdr_Chain::Copy(const ip6_hdr* new_hdr) const if ( chain.empty() ) { - zeek::reporter->InternalWarning("empty IPv6 header chain"); + reporter->InternalWarning("empty IPv6 header chain"); delete rval; return nullptr; } diff --git a/src/IP.h b/src/IP.h index 66275524e0..dff7f5b8b6 100644 --- a/src/IP.h +++ b/src/IP.h @@ -22,8 +22,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(VectorVal, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(FragReassembler, zeek::detail); namespace zeek { -using RecordValPtr = zeek::IntrusivePtr; -using VectorValPtr = zeek::IntrusivePtr; +using RecordValPtr = IntrusivePtr; +using VectorValPtr = IntrusivePtr; #ifdef ENABLE_MOBILE_IPV6 @@ -141,11 +141,11 @@ public: /** * Returns the script-layer record representation of the header. */ - zeek::RecordValPtr ToVal(zeek::VectorValPtr chain) const; - zeek::RecordValPtr ToVal() const; + RecordValPtr ToVal(VectorValPtr chain) const; + RecordValPtr ToVal() const; [[deprecated("Remove in v4.1. Use ToVal() instead.")]] - zeek::RecordVal* BuildRecordVal(zeek::VectorVal* chain = nullptr) const; + RecordVal* BuildRecordVal(VectorVal* chain = nullptr) const; protected: uint8_t type; @@ -221,23 +221,23 @@ public: * option as defined by Mobile IPv6 (RFC 6275), then return it, else * return the source address in the main IPv6 header. */ - zeek::IPAddr SrcAddr() const; + IPAddr SrcAddr() const; /** * If the chain contains a Routing header with non-zero segments left, * then return the last address of the first such header, else return * the destination address of the main IPv6 header. */ - zeek::IPAddr DstAddr() const; + IPAddr DstAddr() const; /** * Returns a vector of ip6_ext_hdr RecordVals that includes script-layer * representation of all extension headers in the chain. */ - zeek::VectorValPtr ToVal() const; + VectorValPtr ToVal() const; [[deprecated("Remove in v4.1. Use ToVal() instead.")]] - zeek::VectorVal* BuildVal() const; + VectorVal* BuildVal() const; protected: // for access to protected ctor that changes next header values that @@ -286,14 +286,14 @@ protected: /** * Home Address of the packet's source as defined by Mobile IPv6 (RFC 6275). */ - zeek::IPAddr* homeAddr = nullptr; + IPAddr* homeAddr = nullptr; #endif /** * The final destination address in chain's first Routing header that has * non-zero segments left. */ - zeek::IPAddr* finalDst = nullptr; + IPAddr* finalDst = nullptr; }; /** @@ -365,19 +365,19 @@ public: /** * Returns the source address held in the IP header. */ - zeek::IPAddr IPHeaderSrcAddr() const; + IPAddr IPHeaderSrcAddr() const; /** * Returns the destination address held in the IP header. */ - zeek::IPAddr IPHeaderDstAddr() const; + IPAddr IPHeaderDstAddr() const; /** * For IPv4 or IPv6 headers that don't contain a Home Address option * (Mobile IPv6, RFC 6275), return source address held in the IP header. * For IPv6 headers that contain a Home Address option, return that address. */ - zeek::IPAddr SrcAddr() const; + IPAddr SrcAddr() const; /** * For IPv4 or IPv6 headers that don't contain a Routing header with @@ -385,7 +385,7 @@ public: * For IPv6 headers with a Routing header that has non-zero segments left, * return the last address in the first such Routing header. */ - zeek::IPAddr DstAddr() const; + IPAddr DstAddr() const; /** * Returns a pointer to the payload of the IP packet, usually an @@ -531,28 +531,28 @@ public: /** * Returns an ip_hdr or ip6_hdr_chain RecordVal. */ - zeek::RecordValPtr ToIPHdrVal() const; + RecordValPtr ToIPHdrVal() const; [[deprecated("Remove in v4.1. Use ToIPHdrVal() instead.")]] - zeek::RecordVal* BuildIPHdrVal() const; + RecordVal* BuildIPHdrVal() const; /** * Returns a pkt_hdr RecordVal, which includes not only the IP header, but * also upper-layer (tcp/udp/icmp) headers. */ - zeek::RecordValPtr ToPktHdrVal() const; + RecordValPtr ToPktHdrVal() const; [[deprecated("Remove in v4.1. Use ToPktHdrVal() instead.")]] - zeek::RecordVal* BuildPktHdrVal() const; + RecordVal* BuildPktHdrVal() const; /** * Same as above, but simply add our values into the record at the * specified starting index. */ - zeek::RecordValPtr ToPktHdrVal(zeek::RecordValPtr pkt_hdr, int sindex) const; + RecordValPtr ToPktHdrVal(RecordValPtr pkt_hdr, int sindex) const; [[deprecated("Remove in v4.1. Use ToPktHdrVal() instead.")]] - zeek::RecordVal* BuildPktHdrVal(zeek::RecordVal* pkt_hdr, int sindex) const; + RecordVal* BuildPktHdrVal(RecordVal* pkt_hdr, int sindex) const; private: const struct ip* ip4 = nullptr; diff --git a/src/IPAddr.cc b/src/IPAddr.cc index a7ce08354d..42df210949 100644 --- a/src/IPAddr.cc +++ b/src/IPAddr.cc @@ -12,11 +12,13 @@ #include "analyzer/Manager.h" -const zeek::IPAddr zeek::IPAddr::v4_unspecified = zeek::IPAddr(in4_addr{}); +namespace zeek { -const zeek::IPAddr zeek::IPAddr::v6_unspecified = zeek::IPAddr(); +const IPAddr IPAddr::v4_unspecified = IPAddr(in4_addr{}); -zeek::detail::ConnIDKey zeek::detail::BuildConnIDKey(const ConnID& id) +const IPAddr IPAddr::v6_unspecified = IPAddr(); + +detail::ConnIDKey detail::BuildConnIDKey(const ConnID& id) { ConnIDKey key; @@ -43,19 +45,17 @@ zeek::detail::ConnIDKey zeek::detail::BuildConnIDKey(const ConnID& id) return key; } -namespace zeek { - -IPAddr::IPAddr(const zeek::String& s) +IPAddr::IPAddr(const String& s) { Init(s.CheckString()); } -zeek::detail::HashKey* IPAddr::GetHashKey() const +detail::HashKey* IPAddr::GetHashKey() const { return MakeHashKey().release(); } -std::unique_ptr IPAddr::MakeHashKey() const +std::unique_ptr IPAddr::MakeHashKey() const { - return std::make_unique((void*)in6.s6_addr, sizeof(in6.s6_addr)); + return std::make_unique((void*)in6.s6_addr, sizeof(in6.s6_addr)); } static inline uint32_t bit_mask32(int bottom_bits) @@ -70,7 +70,7 @@ void IPAddr::Mask(int top_bits_to_keep) { if ( top_bits_to_keep < 0 || top_bits_to_keep > 128 ) { - zeek::reporter->Error("Bad IPAddr::Mask value %d", top_bits_to_keep); + reporter->Error("Bad IPAddr::Mask value %d", top_bits_to_keep); return; } @@ -94,7 +94,7 @@ void IPAddr::ReverseMask(int top_bits_to_chop) { if ( top_bits_to_chop < 0 || top_bits_to_chop > 128 ) { - zeek::reporter->Error("Bad IPAddr::ReverseMask value %d", top_bits_to_chop); + reporter->Error("Bad IPAddr::ReverseMask value %d", top_bits_to_chop); return; } @@ -149,7 +149,7 @@ void IPAddr::Init(const char* s) { if ( ! ConvertString(s, &in6) ) { - zeek::reporter->Error("Bad IP address: %s", s); + reporter->Error("Bad IP address: %s", s); memset(in6.s6_addr, 0, sizeof(in6.s6_addr)); } } @@ -235,7 +235,7 @@ IPPrefix::IPPrefix(const in4_addr& in4, uint8_t length) { if ( length > 32 ) { - zeek::reporter->Error("Bad in4_addr IPPrefix length : %d", length); + reporter->Error("Bad in4_addr IPPrefix length : %d", length); this->length = 0; } @@ -247,7 +247,7 @@ IPPrefix::IPPrefix(const in6_addr& in6, uint8_t length) { if ( length > 128 ) { - zeek::reporter->Error("Bad in6_addr IPPrefix length : %d", length); + reporter->Error("Bad in6_addr IPPrefix length : %d", length); this->length = 0; } @@ -284,7 +284,7 @@ IPPrefix::IPPrefix(const IPAddr& addr, uint8_t length, bool len_is_v6_relative) else { auto vstr = prefix.GetFamily() == IPv4 ? "v4" : "v6"; - zeek::reporter->Error("Bad IPAddr(%s) IPPrefix length : %d", vstr, length); + reporter->Error("Bad IPAddr(%s) IPPrefix length : %d", vstr, length); this->length = 0; } @@ -303,10 +303,10 @@ std::string IPPrefix::AsString() const return prefix.AsString() +"/" + l; } -zeek::detail::HashKey* IPPrefix::GetHashKey() const +detail::HashKey* IPPrefix::GetHashKey() const { return MakeHashKey().release(); } -std::unique_ptr IPPrefix::MakeHashKey() const +std::unique_ptr IPPrefix::MakeHashKey() const { struct { in6_addr ip; @@ -316,7 +316,7 @@ std::unique_ptr IPPrefix::MakeHashKey() const key.ip = prefix.in6; key.len = Length(); - return std::make_unique(&key, sizeof(key)); + return std::make_unique(&key, sizeof(key)); } bool IPPrefix::ConvertString(const char* text, IPPrefix* result) diff --git a/src/IPAddr.h b/src/IPAddr.h index 107995a29f..73d3b5d2cd 100644 --- a/src/IPAddr.h +++ b/src/IPAddr.h @@ -124,7 +124,7 @@ public: * @param s String containing an IP address as either a dotted IPv4 * address or a hex IPv6 address. */ - explicit IPAddr(const zeek::String& s); + explicit IPAddr(const String& s); /** * Constructs an address instance from a raw byte representation. @@ -262,10 +262,10 @@ public: /** * Returns a key that can be used to lookup the IP Address in a hash table. */ - std::unique_ptr MakeHashKey() const; + std::unique_ptr MakeHashKey() const; [[deprecated("Remove in v4.1. Use MakeHashKey().")]] - zeek::detail::HashKey* GetHashKey() const; + detail::HashKey* GetHashKey() const; /** * Masks out lower bits of the address. @@ -644,10 +644,10 @@ public: /** * Returns a key that can be used to lookup the IP Prefix in a hash table. */ - std::unique_ptr MakeHashKey() const; + std::unique_ptr MakeHashKey() const; [[deprecated("Remove in v4.1. Use MakeHashKey().")]] - zeek::detail::HashKey* GetHashKey() const; + detail::HashKey* GetHashKey() const; /** Converts the prefix into the type used internally by the * inter-thread communication. diff --git a/src/IntrusivePtr.h b/src/IntrusivePtr.h index d49aebfb59..ec08fd0143 100644 --- a/src/IntrusivePtr.h +++ b/src/IntrusivePtr.h @@ -99,7 +99,7 @@ public: } IntrusivePtr(const IntrusivePtr& other) noexcept - : IntrusivePtr(zeek::NewRef{}, other.get()) + : IntrusivePtr(NewRef{}, other.get()) { } @@ -183,7 +183,7 @@ template IntrusivePtr make_intrusive(Ts&&... args) { // Assumes that objects start with a reference count of 1! - return {zeek::AdoptRef{}, new T(std::forward(args)...)}; + return {AdoptRef{}, new T(std::forward(args)...)}; } /** @@ -195,7 +195,7 @@ IntrusivePtr make_intrusive(Ts&&... args) template IntrusivePtr cast_intrusive(IntrusivePtr p) noexcept { - return {zeek::AdoptRef{}, static_cast(p.release())}; + return {AdoptRef{}, static_cast(p.release())}; } } // namespace zeek diff --git a/src/List.h b/src/List.h index 2e09b7e34e..7cbbe6a731 100644 --- a/src/List.h +++ b/src/List.h @@ -51,7 +51,7 @@ public: max_entries = size; - entries = (T*) zeek::util::safe_malloc(max_entries * sizeof(T)); + entries = (T*) util::safe_malloc(max_entries * sizeof(T)); } List(const List& b) @@ -60,7 +60,7 @@ public: num_entries = b.num_entries; if ( max_entries ) - entries = (T*) zeek::util::safe_malloc(max_entries * sizeof(T)); + entries = (T*) util::safe_malloc(max_entries * sizeof(T)); else entries = nullptr; @@ -81,7 +81,7 @@ public: List(const T* arr, int n) { num_entries = max_entries = n; - entries = (T*) zeek::util::safe_malloc(max_entries * sizeof(T)); + entries = (T*) util::safe_malloc(max_entries * sizeof(T)); memcpy(entries, arr, n * sizeof(T)); } @@ -98,7 +98,7 @@ public: num_entries = b.num_entries; if ( max_entries ) - entries = (T *) zeek::util::safe_malloc(max_entries * sizeof(T)); + entries = (T *) util::safe_malloc(max_entries * sizeof(T)); else entries = nullptr; @@ -148,7 +148,7 @@ public: if ( new_size != max_entries ) { - entries = (T*) zeek::util::safe_realloc((void*) entries, sizeof(T) * new_size); + entries = (T*) util::safe_realloc((void*) entries, sizeof(T) * new_size); if ( entries ) max_entries = new_size; else @@ -159,7 +159,7 @@ public: } int MemoryAllocation() const - { return padded_sizeof(*this) + zeek::util::pad_size(max_entries * sizeof(T)); } + { return padded_sizeof(*this) + util::pad_size(max_entries * sizeof(T)); } void push_front(const T& a) { diff --git a/src/NFA.h b/src/NFA.h index f78b086eed..1f5915ba66 100644 --- a/src/NFA.h +++ b/src/NFA.h @@ -23,9 +23,9 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Func, zeek); namespace zeek::detail { class NFA_State; -using NFA_state_list = zeek::PList; +using NFA_state_list = PList; -class NFA_State : public zeek::Obj { +class NFA_State : public Obj { public: NFA_State(int sym, EquivClass* ec); explicit NFA_State(CCL* ccl); @@ -82,7 +82,7 @@ public: EpsilonState() : NFA_State(SYM_EPSILON, nullptr) { } }; -class NFA_Machine : public zeek::Obj { +class NFA_Machine : public Obj { public: explicit NFA_Machine(NFA_State* first, NFA_State* final = nullptr); ~NFA_Machine() override; diff --git a/src/NetVar.cc b/src/NetVar.cc index 62b265b5bd..8961d60311 100644 --- a/src/NetVar.cc +++ b/src/NetVar.cc @@ -102,10 +102,6 @@ zeek::StringVal* cmd_line_bpf_filter; zeek::StringVal* global_hash_seed; -// Because of how the BIF include files are built with namespaces already in them, -// these files need to be included separately before the namespace is opened below. - - namespace zeek::detail { int watchdog_interval; @@ -200,6 +196,9 @@ bro_uint_t bits_per_uid; } // namespace zeek::detail. The namespace has be closed here before we include the netvar_def files. +// Because of how the BIF include files are built with namespaces already in them, +// these files need to be included separately before the namespace is opened below. + static void bif_init_event_handlers() { #include "event.bif.netvar_init" @@ -229,14 +228,14 @@ void init_event_handlers() void init_general_global_var() { - table_expire_interval = zeek::id::find_val("table_expire_interval")->AsInterval(); - table_expire_delay = zeek::id::find_val("table_expire_delay")->AsInterval(); - table_incremental_step = zeek::id::find_val("table_incremental_step")->AsCount(); - packet_filter_default = zeek::id::find_val("packet_filter_default")->AsBool(); - sig_max_group_size = zeek::id::find_val("sig_max_group_size")->AsCount(); - check_for_unused_event_handlers = zeek::id::find_val("check_for_unused_event_handlers")->AsBool(); - record_all_packets = zeek::id::find_val("record_all_packets")->AsBool(); - bits_per_uid = zeek::id::find_val("bits_per_uid")->AsCount(); + table_expire_interval = id::find_val("table_expire_interval")->AsInterval(); + table_expire_delay = id::find_val("table_expire_delay")->AsInterval(); + table_incremental_step = id::find_val("table_incremental_step")->AsCount(); + packet_filter_default = id::find_val("packet_filter_default")->AsBool(); + sig_max_group_size = id::find_val("sig_max_group_size")->AsCount(); + check_for_unused_event_handlers = id::find_val("check_for_unused_event_handlers")->AsBool(); + record_all_packets = id::find_val("record_all_packets")->AsBool(); + bits_per_uid = id::find_val("bits_per_uid")->AsCount(); } extern void zeek_legacy_netvar_init(); @@ -245,107 +244,107 @@ void init_net_var() { bif_init_net_var(); - zeek::id::detail::init(); + id::detail::init(); zeek_legacy_netvar_init(); - ignore_checksums = zeek::id::find_val("ignore_checksums")->AsBool(); - partial_connection_ok = zeek::id::find_val("partial_connection_ok")->AsBool(); - tcp_SYN_ack_ok = zeek::id::find_val("tcp_SYN_ack_ok")->AsBool(); - tcp_match_undelivered = zeek::id::find_val("tcp_match_undelivered")->AsBool(); + ignore_checksums = id::find_val("ignore_checksums")->AsBool(); + partial_connection_ok = id::find_val("partial_connection_ok")->AsBool(); + tcp_SYN_ack_ok = id::find_val("tcp_SYN_ack_ok")->AsBool(); + tcp_match_undelivered = id::find_val("tcp_match_undelivered")->AsBool(); - encap_hdr_size = zeek::id::find_val("encap_hdr_size")->AsCount(); + encap_hdr_size = id::find_val("encap_hdr_size")->AsCount(); - frag_timeout = zeek::id::find_val("frag_timeout")->AsInterval(); + frag_timeout = id::find_val("frag_timeout")->AsInterval(); - tcp_SYN_timeout = zeek::id::find_val("tcp_SYN_timeout")->AsInterval(); - tcp_session_timer = zeek::id::find_val("tcp_session_timer")->AsInterval(); - tcp_connection_linger = zeek::id::find_val("tcp_connection_linger")->AsInterval(); - tcp_attempt_delay = zeek::id::find_val("tcp_attempt_delay")->AsInterval(); - tcp_close_delay = zeek::id::find_val("tcp_close_delay")->AsInterval(); - tcp_reset_delay = zeek::id::find_val("tcp_reset_delay")->AsInterval(); - tcp_partial_close_delay = zeek::id::find_val("tcp_partial_close_delay")->AsInterval(); + tcp_SYN_timeout = id::find_val("tcp_SYN_timeout")->AsInterval(); + tcp_session_timer = id::find_val("tcp_session_timer")->AsInterval(); + tcp_connection_linger = id::find_val("tcp_connection_linger")->AsInterval(); + tcp_attempt_delay = id::find_val("tcp_attempt_delay")->AsInterval(); + tcp_close_delay = id::find_val("tcp_close_delay")->AsInterval(); + tcp_reset_delay = id::find_val("tcp_reset_delay")->AsInterval(); + tcp_partial_close_delay = id::find_val("tcp_partial_close_delay")->AsInterval(); - tcp_max_initial_window = zeek::id::find_val("tcp_max_initial_window")->AsCount(); - tcp_max_above_hole_without_any_acks = zeek::id::find_val("tcp_max_above_hole_without_any_acks")->AsCount(); - tcp_excessive_data_without_further_acks = zeek::id::find_val("tcp_excessive_data_without_further_acks")->AsCount(); - tcp_max_old_segments = zeek::id::find_val("tcp_max_old_segments")->AsCount(); + tcp_max_initial_window = id::find_val("tcp_max_initial_window")->AsCount(); + tcp_max_above_hole_without_any_acks = id::find_val("tcp_max_above_hole_without_any_acks")->AsCount(); + tcp_excessive_data_without_further_acks = id::find_val("tcp_excessive_data_without_further_acks")->AsCount(); + tcp_max_old_segments = id::find_val("tcp_max_old_segments")->AsCount(); - non_analyzed_lifetime = zeek::id::find_val("non_analyzed_lifetime")->AsInterval(); - tcp_inactivity_timeout = zeek::id::find_val("tcp_inactivity_timeout")->AsInterval(); - udp_inactivity_timeout = zeek::id::find_val("udp_inactivity_timeout")->AsInterval(); - icmp_inactivity_timeout = zeek::id::find_val("icmp_inactivity_timeout")->AsInterval(); + non_analyzed_lifetime = id::find_val("non_analyzed_lifetime")->AsInterval(); + tcp_inactivity_timeout = id::find_val("tcp_inactivity_timeout")->AsInterval(); + udp_inactivity_timeout = id::find_val("udp_inactivity_timeout")->AsInterval(); + icmp_inactivity_timeout = id::find_val("icmp_inactivity_timeout")->AsInterval(); - tcp_storm_thresh = zeek::id::find_val("tcp_storm_thresh")->AsCount(); - tcp_storm_interarrival_thresh = zeek::id::find_val("tcp_storm_interarrival_thresh")->AsInterval(); + tcp_storm_thresh = id::find_val("tcp_storm_thresh")->AsCount(); + tcp_storm_interarrival_thresh = id::find_val("tcp_storm_interarrival_thresh")->AsInterval(); tcp_content_deliver_all_orig = - bool(zeek::id::find_val("tcp_content_deliver_all_orig")->AsBool()); + bool(id::find_val("tcp_content_deliver_all_orig")->AsBool()); tcp_content_deliver_all_resp = - bool(zeek::id::find_val("tcp_content_deliver_all_resp")->AsBool()); + bool(id::find_val("tcp_content_deliver_all_resp")->AsBool()); udp_content_deliver_all_orig = - bool(zeek::id::find_val("udp_content_deliver_all_orig")->AsBool()); + bool(id::find_val("udp_content_deliver_all_orig")->AsBool()); udp_content_deliver_all_resp = - bool(zeek::id::find_val("udp_content_deliver_all_resp")->AsBool()); + bool(id::find_val("udp_content_deliver_all_resp")->AsBool()); udp_content_delivery_ports_use_resp = - bool(zeek::id::find_val("udp_content_delivery_ports_use_resp")->AsBool()); + bool(id::find_val("udp_content_delivery_ports_use_resp")->AsBool()); - dns_session_timeout = zeek::id::find_val("dns_session_timeout")->AsInterval(); - rpc_timeout = zeek::id::find_val("rpc_timeout")->AsInterval(); + dns_session_timeout = id::find_val("dns_session_timeout")->AsInterval(); + rpc_timeout = id::find_val("rpc_timeout")->AsInterval(); - watchdog_interval = int(zeek::id::find_val("watchdog_interval")->AsInterval()); + watchdog_interval = int(id::find_val("watchdog_interval")->AsInterval()); - max_timer_expires = zeek::id::find_val("max_timer_expires")->AsCount(); + max_timer_expires = id::find_val("max_timer_expires")->AsCount(); - mime_segment_length = zeek::id::find_val("mime_segment_length")->AsCount(); - mime_segment_overlap_length = zeek::id::find_val("mime_segment_overlap_length")->AsCount(); + mime_segment_length = id::find_val("mime_segment_length")->AsCount(); + mime_segment_overlap_length = id::find_val("mime_segment_overlap_length")->AsCount(); - http_entity_data_delivery_size = zeek::id::find_val("http_entity_data_delivery_size")->AsCount(); - truncate_http_URI = zeek::id::find_val("truncate_http_URI")->AsInt(); + http_entity_data_delivery_size = id::find_val("http_entity_data_delivery_size")->AsCount(); + truncate_http_URI = id::find_val("truncate_http_URI")->AsInt(); - dns_skip_all_auth = zeek::id::find_val("dns_skip_all_auth")->AsBool(); - dns_skip_all_addl = zeek::id::find_val("dns_skip_all_addl")->AsBool(); - dns_max_queries = zeek::id::find_val("dns_max_queries")->AsCount(); + dns_skip_all_auth = id::find_val("dns_skip_all_auth")->AsBool(); + dns_skip_all_addl = id::find_val("dns_skip_all_addl")->AsBool(); + dns_max_queries = id::find_val("dns_max_queries")->AsCount(); stp_delta = 0.0; - if ( const auto& v = zeek::id::find_val("stp_delta") ) stp_delta = v->AsInterval(); + if ( const auto& v = id::find_val("stp_delta") ) stp_delta = v->AsInterval(); stp_idle_min = 0.0; - if ( const auto& v = zeek::id::find_val("stp_idle_min") ) stp_delta = v->AsInterval(); + if ( const auto& v = id::find_val("stp_idle_min") ) stp_delta = v->AsInterval(); orig_addr_anonymization = 0; - if ( const auto& id = zeek::id::find("orig_addr_anonymization") ) + if ( const auto& id = id::find("orig_addr_anonymization") ) if ( const auto& v = id->GetVal() ) orig_addr_anonymization = v->AsInt(); resp_addr_anonymization = 0; - if ( const auto& id = zeek::id::find("resp_addr_anonymization") ) + if ( const auto& id = id::find("resp_addr_anonymization") ) if ( const auto& v = id->GetVal() ) resp_addr_anonymization = v->AsInt(); other_addr_anonymization = 0; - if ( const auto& id = zeek::id::find("other_addr_anonymization") ) + if ( const auto& id = id::find("other_addr_anonymization") ) if ( const auto& v = id->GetVal() ) other_addr_anonymization = v->AsInt(); connection_status_update_interval = 0.0; - if ( const auto& id = zeek::id::find("connection_status_update_interval") ) + if ( const auto& id = id::find("connection_status_update_interval") ) if ( const auto& v = id->GetVal() ) connection_status_update_interval = v->AsInterval(); - expensive_profiling_multiple = zeek::id::find_val("expensive_profiling_multiple")->AsCount(); - profiling_interval = zeek::id::find_val("profiling_interval")->AsInterval(); - segment_profiling = zeek::id::find_val("segment_profiling")->AsBool(); + expensive_profiling_multiple = id::find_val("expensive_profiling_multiple")->AsCount(); + profiling_interval = id::find_val("profiling_interval")->AsInterval(); + segment_profiling = id::find_val("segment_profiling")->AsBool(); - pkt_profile_mode = zeek::id::find_val("pkt_profile_mode")->InternalInt(); - pkt_profile_freq = zeek::id::find_val("pkt_profile_freq")->AsDouble(); + pkt_profile_mode = id::find_val("pkt_profile_mode")->InternalInt(); + pkt_profile_freq = id::find_val("pkt_profile_freq")->AsDouble(); - load_sample_freq = zeek::id::find_val("load_sample_freq")->AsCount(); + load_sample_freq = id::find_val("load_sample_freq")->AsCount(); - dpd_reassemble_first_packets = zeek::id::find_val("dpd_reassemble_first_packets")->AsBool(); - dpd_buffer_size = zeek::id::find_val("dpd_buffer_size")->AsCount(); - dpd_match_only_beginning = zeek::id::find_val("dpd_match_only_beginning")->AsBool(); - dpd_late_match_stop = zeek::id::find_val("dpd_late_match_stop")->AsBool(); - dpd_ignore_ports = zeek::id::find_val("dpd_ignore_ports")->AsBool(); + dpd_reassemble_first_packets = id::find_val("dpd_reassemble_first_packets")->AsBool(); + dpd_buffer_size = id::find_val("dpd_buffer_size")->AsCount(); + dpd_match_only_beginning = id::find_val("dpd_match_only_beginning")->AsBool(); + dpd_late_match_stop = id::find_val("dpd_late_match_stop")->AsBool(); + dpd_ignore_ports = id::find_val("dpd_ignore_ports")->AsBool(); - timer_mgr_inactivity_timeout = zeek::id::find_val("timer_mgr_inactivity_timeout")->AsInterval(); + timer_mgr_inactivity_timeout = id::find_val("timer_mgr_inactivity_timeout")->AsInterval(); } } // namespace zeek::detail diff --git a/src/Notifier.cc b/src/Notifier.cc index 18dc1b890c..7a12e67ddc 100644 --- a/src/Notifier.cc +++ b/src/Notifier.cc @@ -12,12 +12,12 @@ namespace zeek::notifier::detail { Receiver::Receiver() { - DBG_LOG(zeek::DBG_NOTIFIERS, "creating receiver %p", this); + DBG_LOG(DBG_NOTIFIERS, "creating receiver %p", this); } Receiver::~Receiver() { - DBG_LOG(zeek::DBG_NOTIFIERS, "deleting receiver %p", this); + DBG_LOG(DBG_NOTIFIERS, "deleting receiver %p", this); } Registry::~Registry() @@ -28,7 +28,7 @@ Registry::~Registry() void Registry::Register(Modifiable* m, Receiver* r) { - DBG_LOG(zeek::DBG_NOTIFIERS, "registering object %p for receiver %p", m, r); + DBG_LOG(DBG_NOTIFIERS, "registering object %p for receiver %p", m, r); registrations.insert({m, r}); ++m->num_receivers; @@ -36,7 +36,7 @@ void Registry::Register(Modifiable* m, Receiver* r) void Registry::Unregister(Modifiable* m, Receiver* r) { - DBG_LOG(zeek::DBG_NOTIFIERS, "unregistering object %p from receiver %p", m, r); + DBG_LOG(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++ ) @@ -52,7 +52,7 @@ void Registry::Unregister(Modifiable* m, Receiver* r) void Registry::Unregister(Modifiable* m) { - DBG_LOG(zeek::DBG_NOTIFIERS, "unregistering object %p from all notifiers", m); + DBG_LOG(DBG_NOTIFIERS, "unregistering object %p from all notifiers", m); auto x = registrations.equal_range(m); for ( auto i = x.first; i != x.second; i++ ) @@ -63,7 +63,7 @@ void Registry::Unregister(Modifiable* m) void Registry::Modified(Modifiable* m) { - DBG_LOG(zeek::DBG_NOTIFIERS, "object %p has been modified", m); + DBG_LOG(DBG_NOTIFIERS, "object %p has been modified", m); auto x = registrations.equal_range(m); for ( auto i = x.first; i != x.second; i++ ) diff --git a/src/Obj.cc b/src/Obj.cc index 0060774490..ffafae0dd1 100644 --- a/src/Obj.cc +++ b/src/Obj.cc @@ -16,7 +16,7 @@ namespace detail { Location start_location("", 0, 0, 0, 0); Location end_location("", 0, 0, 0, 0); -void Location::Describe(zeek::ODesc* d) const +void Location::Describe(ODesc* d) const { if ( filename ) { @@ -45,7 +45,7 @@ void Location::Describe(zeek::ODesc* d) const bool Location::operator==(const Location& l) const { if ( filename == l.filename || - (filename && l.filename && zeek::util::streq(filename, l.filename)) ) + (filename && l.filename && util::streq(filename, l.filename)) ) return first_line == l.first_line && last_line == l.last_line; else return false; @@ -65,10 +65,10 @@ Obj::~Obj() void Obj::Warn(const char* msg, const Obj* obj2, bool pinpoint_only, const detail::Location* expr_location) const { - zeek::ODesc d; + ODesc d; DoMsg(&d, msg, obj2, pinpoint_only, expr_location); - zeek::reporter->Warning("%s", d.Description()); - zeek::reporter->PopLocation(); + reporter->Warning("%s", d.Description()); + reporter->PopLocation(); } void Obj::Error(const char* msg, const Obj* obj2, bool pinpoint_only, const detail::Location* expr_location) const @@ -76,10 +76,10 @@ void Obj::Error(const char* msg, const Obj* obj2, bool pinpoint_only, const deta if ( suppress_errors ) return; - zeek::ODesc d; + ODesc d; DoMsg(&d, msg, obj2, pinpoint_only, expr_location); - zeek::reporter->Error("%s", d.Description()); - zeek::reporter->PopLocation(); + reporter->Error("%s", d.Description()); + reporter->PopLocation(); } void Obj::BadTag(const char* msg, const char* t1, const char* t2) const @@ -93,35 +93,35 @@ void Obj::BadTag(const char* msg, const char* t1, const char* t2) const else snprintf(out, sizeof(out), "%s", msg); - zeek::ODesc d; + ODesc d; DoMsg(&d, out); - zeek::reporter->FatalErrorWithCore("%s", d.Description()); - zeek::reporter->PopLocation(); + reporter->FatalErrorWithCore("%s", d.Description()); + reporter->PopLocation(); } void Obj::Internal(const char* msg) const { - zeek::ODesc d; + ODesc d; DoMsg(&d, msg); - auto rcs = zeek::render_call_stack(); + auto rcs = render_call_stack(); if ( rcs.empty() ) - zeek::reporter->InternalError("%s", d.Description()); + reporter->InternalError("%s", d.Description()); else - zeek::reporter->InternalError("%s, call stack: %s", d.Description(), rcs.data()); + reporter->InternalError("%s, call stack: %s", d.Description(), rcs.data()); - zeek::reporter->PopLocation(); + reporter->PopLocation(); } void Obj::InternalWarning(const char* msg) const { - zeek::ODesc d; + ODesc d; DoMsg(&d, msg); - zeek::reporter->InternalWarning("%s", d.Description()); - zeek::reporter->PopLocation(); + reporter->InternalWarning("%s", d.Description()); + reporter->PopLocation(); } -void Obj::AddLocation(zeek::ODesc* d) const +void Obj::AddLocation(ODesc* d) const { if ( ! location ) { @@ -137,10 +137,10 @@ bool Obj::SetLocationInfo(const detail::Location* start, const detail::Location* if ( ! start || ! end ) return false; - if ( end->filename && ! zeek::util::streq(start->filename, end->filename) ) + if ( end->filename && ! util::streq(start->filename, end->filename) ) return false; - if ( location && (start == &zeek::detail::no_location || end == &zeek::detail::no_location) ) + if ( location && (start == &detail::no_location || end == &detail::no_location) ) // We already have a better location, so don't use this one. return true; @@ -162,7 +162,7 @@ void Obj::UpdateLocationEndInfo(const detail::Location& end) location->last_column = end.last_column; } -void Obj::DoMsg(zeek::ODesc* d, const char s1[], const Obj* obj2, +void Obj::DoMsg(ODesc* d, const char s1[], const Obj* obj2, bool pinpoint_only, const detail::Location* expr_location) const { d->SetShort(); @@ -171,16 +171,16 @@ void Obj::DoMsg(zeek::ODesc* d, const char s1[], const Obj* obj2, PinPoint(d, obj2, pinpoint_only); const detail::Location* loc2 = nullptr; - if ( obj2 && obj2->GetLocationInfo() != &zeek::detail::no_location && + if ( obj2 && obj2->GetLocationInfo() != &detail::no_location && *obj2->GetLocationInfo() != *GetLocationInfo() ) loc2 = obj2->GetLocationInfo(); else if ( expr_location ) loc2 = expr_location; - zeek::reporter->PushLocation(GetLocationInfo(), loc2); + reporter->PushLocation(GetLocationInfo(), loc2); } -void Obj::PinPoint(zeek::ODesc* d, const Obj* obj2, bool pinpoint_only) const +void Obj::PinPoint(ODesc* d, const Obj* obj2, bool pinpoint_only) const { d->Add(" ("); Describe(d); @@ -195,15 +195,15 @@ void Obj::PinPoint(zeek::ODesc* d, const Obj* obj2, bool pinpoint_only) const void Obj::Print() const { - static zeek::File fstderr(stderr); - zeek::ODesc d(DESC_READABLE, &fstderr); + static File fstderr(stderr); + ODesc d(DESC_READABLE, &fstderr); Describe(&d); d.Add("\n"); } void bad_ref(int type) { - zeek::reporter->InternalError("bad reference count [%d]", type); + reporter->InternalError("bad reference count [%d]", type); abort(); } diff --git a/src/Obj.h b/src/Obj.h index 08466540f9..7a393e09bc 100644 --- a/src/Obj.h +++ b/src/Obj.h @@ -21,7 +21,7 @@ public: Location() = default; - void Describe(zeek::ODesc* d) const; + void Describe(ODesc* d) const; bool operator==(const Location& l) const; bool operator!=(const Location& l) const @@ -105,9 +105,9 @@ public: [[noreturn]] void Internal(const char* msg) const; void InternalWarning(const char* msg) const; - virtual void Describe(zeek::ODesc* d) const { /* FIXME: Add code */ }; + virtual void Describe(ODesc* d) const { /* FIXME: Add code */ }; - void AddLocation(zeek::ODesc* d) const; + void AddLocation(ODesc* d) const; // Get location info for debugging. const detail::Location* GetLocationInfo() const @@ -144,9 +144,9 @@ protected: private: friend class SuppressErrors; - void DoMsg(zeek::ODesc* d, const char s1[], const Obj* obj2 = nullptr, + void DoMsg(ODesc* d, const char s1[], const Obj* obj2 = nullptr, bool pinpoint_only = false, const detail::Location* expr_location = nullptr) const; - void PinPoint(zeek::ODesc* d, const Obj* obj2 = nullptr, + void PinPoint(ODesc* d, const Obj* obj2 = nullptr, bool pinpoint_only = false) const; friend inline void Ref(Obj* o); diff --git a/src/OpaqueVal.cc b/src/OpaqueVal.cc index 459d2deb4e..87e23c9f11 100644 --- a/src/OpaqueVal.cc +++ b/src/OpaqueVal.cc @@ -39,10 +39,10 @@ OpaqueMgr* OpaqueMgr::mgr() return &mgr; } -OpaqueVal::OpaqueVal(zeek::OpaqueType* t) : OpaqueVal({zeek::NewRef{}, t}) +OpaqueVal::OpaqueVal(OpaqueType* t) : OpaqueVal({NewRef{}, t}) {} -OpaqueVal::OpaqueVal(zeek::OpaqueTypePtr t) : Val(std::move(t)) +OpaqueVal::OpaqueVal(OpaqueTypePtr t) : Val(std::move(t)) {} OpaqueVal::~OpaqueVal() @@ -54,7 +54,7 @@ const std::string& OpaqueMgr::TypeID(const OpaqueVal* v) const auto x = _types.find(v->OpaqueName()); if ( x == _types.end() ) - zeek::reporter->InternalError("OpaqueMgr::TypeID: opaque type %s not registered", + reporter->InternalError("OpaqueMgr::TypeID: opaque type %s not registered", v->OpaqueName()); return x->first; @@ -98,12 +98,12 @@ OpaqueValPtr OpaqueVal::Unserialize(const broker::data& data) return val; } -broker::expected OpaqueVal::SerializeType(const zeek::TypePtr& t) +broker::expected OpaqueVal::SerializeType(const TypePtr& t) { - if ( t->InternalType() == zeek::TYPE_INTERNAL_ERROR ) + if ( t->InternalType() == TYPE_INTERNAL_ERROR ) return broker::ec::invalid_data; - if ( t->InternalType() == zeek::TYPE_INTERNAL_OTHER ) + if ( t->InternalType() == TYPE_INTERNAL_OTHER ) { // Serialize by name. assert(t->GetName().size()); @@ -114,7 +114,7 @@ broker::expected OpaqueVal::SerializeType(const zeek::TypePtr& t) return {broker::vector{false, static_cast(t->Tag())}}; } -zeek::TypePtr OpaqueVal::UnserializeType(const broker::data& data) +TypePtr OpaqueVal::UnserializeType(const broker::data& data) { auto v = caf::get_if(&data); if ( ! (v && v->size() == 2) ) @@ -130,7 +130,7 @@ zeek::TypePtr OpaqueVal::UnserializeType(const broker::data& data) if ( ! name ) return nullptr; - const auto& id = zeek::detail::global_scope()->Find(*name); + const auto& id = detail::global_scope()->Find(*name); if ( ! id ) return nullptr; @@ -144,7 +144,7 @@ zeek::TypePtr OpaqueVal::UnserializeType(const broker::data& data) if ( ! tag ) return nullptr; - return zeek::base_type(static_cast(*tag)); + return base_type(static_cast(*tag)); } ValPtr OpaqueVal::DoClone(CloneState* state) @@ -174,7 +174,7 @@ bool HashVal::Init() StringValPtr HashVal::Get() { if ( ! valid ) - return zeek::val_mgr->EmptyString(); + return val_mgr->EmptyString(); auto result = DoGet(); valid = false; @@ -205,15 +205,15 @@ bool HashVal::DoFeed(const void*, size_t) StringValPtr HashVal::DoGet() { assert(! "missing implementation of DoGet()"); - return zeek::val_mgr->EmptyString(); + return val_mgr->EmptyString(); } -HashVal::HashVal(zeek::OpaqueTypePtr t) : OpaqueVal(std::move(t)) +HashVal::HashVal(OpaqueTypePtr t) : OpaqueVal(std::move(t)) { valid = false; } -HashVal::HashVal(zeek::OpaqueType* t) : HashVal({zeek::NewRef{}, t}) +HashVal::HashVal(OpaqueType* t) : HashVal({NewRef{}, t}) {} MD5Val::MD5Val() : HashVal(md5_type) @@ -228,16 +228,16 @@ MD5Val::~MD5Val() void HashVal::digest_one(EVP_MD_CTX* h, const Val* v) { - if ( v->GetType()->Tag() == zeek::TYPE_STRING ) + if ( v->GetType()->Tag() == TYPE_STRING ) { const String* str = v->AsString(); - zeek::detail::hash_update(h, str->Bytes(), str->Len()); + detail::hash_update(h, str->Bytes(), str->Len()); } else { ODesc d(DESC_BINARY); v->Describe(&d); - zeek::detail::hash_update(h, (const u_char *) d.Bytes(), d.Len()); + detail::hash_update(h, (const u_char *) d.Bytes(), d.Len()); } } @@ -248,7 +248,7 @@ void HashVal::digest_one(EVP_MD_CTX* h, const ValPtr& v) ValPtr MD5Val::DoClone(CloneState* state) { - auto out = zeek::make_intrusive(); + auto out = make_intrusive(); if ( IsValid() ) { @@ -264,7 +264,7 @@ ValPtr MD5Val::DoClone(CloneState* state) bool MD5Val::DoInit() { assert(! IsValid()); - ctx = zeek::detail::hash_init(zeek::detail::Hash_MD5); + ctx = detail::hash_init(detail::Hash_MD5); return true; } @@ -273,18 +273,18 @@ bool MD5Val::DoFeed(const void* data, size_t size) if ( ! IsValid() ) return false; - zeek::detail::hash_update(ctx, data, size); + detail::hash_update(ctx, data, size); return true; } StringValPtr MD5Val::DoGet() { if ( ! IsValid() ) - return zeek::val_mgr->EmptyString(); + return val_mgr->EmptyString(); u_char digest[MD5_DIGEST_LENGTH]; - zeek::detail::hash_final(ctx, digest); - return zeek::make_intrusive(zeek::detail::md5_digest_print(digest)); + detail::hash_final(ctx, digest); + return make_intrusive(detail::md5_digest_print(digest)); } IMPLEMENT_OPAQUE_VALUE(MD5Val) @@ -368,7 +368,7 @@ SHA1Val::~SHA1Val() ValPtr SHA1Val::DoClone(CloneState* state) { - auto out = zeek::make_intrusive(); + auto out = make_intrusive(); if ( IsValid() ) { @@ -384,7 +384,7 @@ ValPtr SHA1Val::DoClone(CloneState* state) bool SHA1Val::DoInit() { assert(! IsValid()); - ctx = zeek::detail::hash_init(zeek::detail::Hash_SHA1); + ctx = detail::hash_init(detail::Hash_SHA1); return true; } @@ -393,18 +393,18 @@ bool SHA1Val::DoFeed(const void* data, size_t size) if ( ! IsValid() ) return false; - zeek::detail::hash_update(ctx, data, size); + detail::hash_update(ctx, data, size); return true; } StringValPtr SHA1Val::DoGet() { if ( ! IsValid() ) - return zeek::val_mgr->EmptyString(); + return val_mgr->EmptyString(); u_char digest[SHA_DIGEST_LENGTH]; - zeek::detail::hash_final(ctx, digest); - return zeek::make_intrusive(zeek::detail::sha1_digest_print(digest)); + detail::hash_final(ctx, digest); + return make_intrusive(detail::sha1_digest_print(digest)); } IMPLEMENT_OPAQUE_VALUE(SHA1Val) @@ -491,7 +491,7 @@ SHA256Val::~SHA256Val() ValPtr SHA256Val::DoClone(CloneState* state) { - auto out = zeek::make_intrusive(); + auto out = make_intrusive(); if ( IsValid() ) { @@ -507,7 +507,7 @@ ValPtr SHA256Val::DoClone(CloneState* state) bool SHA256Val::DoInit() { assert( ! IsValid() ); - ctx = zeek::detail::hash_init(zeek::detail::Hash_SHA256); + ctx = detail::hash_init(detail::Hash_SHA256); return true; } @@ -516,18 +516,18 @@ bool SHA256Val::DoFeed(const void* data, size_t size) if ( ! IsValid() ) return false; - zeek::detail::hash_update(ctx, data, size); + detail::hash_update(ctx, data, size); return true; } StringValPtr SHA256Val::DoGet() { if ( ! IsValid() ) - return zeek::val_mgr->EmptyString(); + return val_mgr->EmptyString(); u_char digest[SHA256_DIGEST_LENGTH]; - zeek::detail::hash_final(ctx, digest); - return zeek::make_intrusive(zeek::detail::sha256_digest_print(digest)); + detail::hash_final(ctx, digest); + return make_intrusive(detail::sha256_digest_print(digest)); } IMPLEMENT_OPAQUE_VALUE(SHA256Val) @@ -706,7 +706,7 @@ BloomFilterVal::BloomFilterVal() bloom_filter = nullptr; } -BloomFilterVal::BloomFilterVal(zeek::probabilistic::BloomFilter* bf) +BloomFilterVal::BloomFilterVal(probabilistic::BloomFilter* bf) : OpaqueVal(bloomfilter_type) { hash = nullptr; @@ -717,24 +717,24 @@ ValPtr BloomFilterVal::DoClone(CloneState* state) { if ( bloom_filter ) { - auto bf = zeek::make_intrusive(bloom_filter->Clone()); + auto bf = make_intrusive(bloom_filter->Clone()); bf->Typify(type); return state->NewClone(this, std::move(bf)); } - return state->NewClone(this, zeek::make_intrusive()); + return state->NewClone(this, make_intrusive()); } -bool BloomFilterVal::Typify(zeek::TypePtr arg_type) +bool BloomFilterVal::Typify(TypePtr arg_type) { if ( type ) return false; type = std::move(arg_type); - auto tl = zeek::make_intrusive(type); + auto tl = make_intrusive(type); tl->Append(type); - hash = new zeek::detail::CompositeHash(std::move(tl)); + hash = new detail::CompositeHash(std::move(tl)); return true; } @@ -774,30 +774,30 @@ BloomFilterValPtr BloomFilterVal::Merge(const BloomFilterVal* x, y->Type() && ! same_type(x->Type(), y->Type()) ) { - zeek::reporter->Error("cannot merge Bloom filters with different types"); + reporter->Error("cannot merge Bloom filters with different types"); return nullptr; } if ( typeid(*x->bloom_filter) != typeid(*y->bloom_filter) ) { - zeek::reporter->Error("cannot merge different Bloom filter types"); + reporter->Error("cannot merge different Bloom filter types"); return nullptr; } - zeek::probabilistic::BloomFilter* copy = x->bloom_filter->Clone(); + probabilistic::BloomFilter* copy = x->bloom_filter->Clone(); if ( ! copy->Merge(y->bloom_filter) ) { delete copy; - zeek::reporter->Error("failed to merge Bloom filter"); + reporter->Error("failed to merge Bloom filter"); return nullptr; } - auto merged = zeek::make_intrusive(copy); + auto merged = make_intrusive(copy); if ( x->Type() && ! merged->Typify(x->Type()) ) { - zeek::reporter->Error("failed to set type on merged Bloom filter"); + reporter->Error("failed to set type on merged Bloom filter"); return nullptr; } @@ -851,7 +851,7 @@ bool BloomFilterVal::DoUnserialize(const broker::data& data) return false; } - auto bf = zeek::probabilistic::BloomFilter::Unserialize((*v)[1]); + auto bf = probabilistic::BloomFilter::Unserialize((*v)[1]); if ( ! bf ) return false; @@ -865,7 +865,7 @@ CardinalityVal::CardinalityVal() : OpaqueVal(cardinality_type) hash = nullptr; } -CardinalityVal::CardinalityVal(zeek::probabilistic::detail::CardinalityCounter* arg_c) +CardinalityVal::CardinalityVal(probabilistic::detail::CardinalityCounter* arg_c) : OpaqueVal(cardinality_type) { c = arg_c; @@ -881,19 +881,19 @@ CardinalityVal::~CardinalityVal() ValPtr CardinalityVal::DoClone(CloneState* state) { return state->NewClone(this, - zeek::make_intrusive(new zeek::probabilistic::detail::CardinalityCounter(*c))); + make_intrusive(new probabilistic::detail::CardinalityCounter(*c))); } -bool CardinalityVal::Typify(zeek::TypePtr arg_type) +bool CardinalityVal::Typify(TypePtr arg_type) { if ( type ) return false; type = std::move(arg_type); - auto tl = zeek::make_intrusive(type); + auto tl = make_intrusive(type); tl->Append(type); - hash = new zeek::detail::CompositeHash(std::move(tl)); + hash = new detail::CompositeHash(std::move(tl)); return true; } @@ -945,7 +945,7 @@ bool CardinalityVal::DoUnserialize(const broker::data& data) return false; } - auto cu = zeek::probabilistic::detail::CardinalityCounter::Unserialize((*v)[1]); + auto cu = probabilistic::detail::CardinalityCounter::Unserialize((*v)[1]); if ( ! cu ) return false; @@ -961,12 +961,12 @@ ParaglobVal::ParaglobVal(std::unique_ptr p) VectorValPtr ParaglobVal::Get(StringVal* &pattern) { - auto rval = zeek::make_intrusive(zeek::id::string_vec); + auto rval = make_intrusive(id::string_vec); std::string string_pattern (reinterpret_cast(pattern->Bytes()), pattern->Len()); std::vector matches = this->internal_paraglob->get(string_pattern); for ( size_t i = 0; i < matches.size(); i++ ) - rval->Assign(i, zeek::make_intrusive(matches.at(i))); + rval->Assign(i, make_intrusive(matches.at(i))); return rval; } @@ -1008,12 +1008,12 @@ bool ParaglobVal::DoUnserialize(const broker::data& data) } catch (const paraglob::underflow_error& e) { - zeek::reporter->Error("Paraglob underflow error -> %s", e.what()); + reporter->Error("Paraglob underflow error -> %s", e.what()); return false; } catch (const paraglob::overflow_error& e) { - zeek::reporter->Error("Paraglob overflow error -> %s", e.what()); + reporter->Error("Paraglob overflow error -> %s", e.what()); return false; } @@ -1023,17 +1023,17 @@ bool ParaglobVal::DoUnserialize(const broker::data& data) ValPtr ParaglobVal::DoClone(CloneState* state) { try { - return zeek::make_intrusive + return make_intrusive (std::make_unique(this->internal_paraglob->serialize())); } catch (const paraglob::underflow_error& e) { - zeek::reporter->Error("Paraglob underflow error while cloning -> %s", e.what()); + reporter->Error("Paraglob underflow error while cloning -> %s", e.what()); return nullptr; } catch (const paraglob::overflow_error& e) { - zeek::reporter->Error("Paraglob overflow error while cloning -> %s", e.what()); + reporter->Error("Paraglob overflow error while cloning -> %s", e.what()); return nullptr; } } diff --git a/src/OpaqueVal.h b/src/OpaqueVal.h index 399c9fa4a4..91bd0bd36f 100644 --- a/src/OpaqueVal.h +++ b/src/OpaqueVal.h @@ -20,10 +20,10 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(CardinalityCounter, zeek, probabilistic, detail) namespace zeek { class OpaqueVal; -using OpaqueValPtr = zeek::IntrusivePtr; +using OpaqueValPtr = IntrusivePtr; class BloomFilterVal; -using BloomFilterValPtr = zeek::IntrusivePtr; +using BloomFilterValPtr = IntrusivePtr; /** * Singleton that registers all available all available types of opaque @@ -98,8 +98,8 @@ private: class OpaqueVal : public Val { public: [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit OpaqueVal(zeek::OpaqueType* t); - explicit OpaqueVal(zeek::OpaqueTypePtr t); + explicit OpaqueVal(OpaqueType* t); + explicit OpaqueVal(OpaqueTypePtr t); ~OpaqueVal() override; /** @@ -158,26 +158,26 @@ protected: * Helper function for derived class that need to record a type * during serialization. */ - static broker::expected SerializeType(const zeek::TypePtr& t); + static broker::expected SerializeType(const TypePtr& t); /** * Helper function for derived class that need to restore a type * during unserialization. Returns the type at reference count +1. */ - static zeek::TypePtr UnserializeType(const broker::data& data); + static TypePtr UnserializeType(const broker::data& data); }; class HashVal : public OpaqueVal { public: template - static void digest_all(zeek::detail::HashAlgorithm alg, const T& vlist, u_char* result) + static void digest_all(detail::HashAlgorithm alg, const T& vlist, u_char* result) { - auto h = zeek::detail::hash_init(alg); + auto h = detail::hash_init(alg); for ( const auto& v : vlist ) digest_one(h, v); - zeek::detail::hash_final(h, result); + detail::hash_final(h, result); } bool IsValid() const; @@ -192,8 +192,8 @@ protected: HashVal() { valid = false; } [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit HashVal(zeek::OpaqueType* t); - explicit HashVal(zeek::OpaqueTypePtr t); + explicit HashVal(OpaqueType* t); + explicit HashVal(OpaqueTypePtr t); virtual bool DoInit(); virtual bool DoFeed(const void* data, size_t size); @@ -208,7 +208,7 @@ class MD5Val : public HashVal { public: template static void digest(const T& vlist, u_char result[MD5_DIGEST_LENGTH]) - { digest_all(zeek::detail::Hash_MD5, vlist, result); } + { digest_all(detail::Hash_MD5, vlist, result); } template static void hmac(const T& vlist, @@ -220,7 +220,7 @@ public: for ( int i = 0; i < MD5_DIGEST_LENGTH; ++i ) result[i] ^= key[i]; - zeek::detail::internal_md5(result, MD5_DIGEST_LENGTH, result); + detail::internal_md5(result, MD5_DIGEST_LENGTH, result); } MD5Val(); @@ -244,7 +244,7 @@ class SHA1Val : public HashVal { public: template static void digest(const T& vlist, u_char result[SHA_DIGEST_LENGTH]) - { digest_all(zeek::detail::Hash_SHA1, vlist, result); } + { digest_all(detail::Hash_SHA1, vlist, result); } SHA1Val(); ~SHA1Val(); @@ -267,7 +267,7 @@ class SHA256Val : public HashVal { public: template static void digest(const T& vlist, u_char result[SHA256_DIGEST_LENGTH]) - { digest_all(zeek::detail::Hash_SHA256, vlist, result); } + { digest_all(detail::Hash_SHA256, vlist, result); } SHA256Val(); ~SHA256Val(); @@ -299,20 +299,20 @@ protected: DECLARE_OPAQUE_VALUE(EntropyVal) private: - zeek::detail::RandTest state; + detail::RandTest state; }; class BloomFilterVal : public OpaqueVal { public: - explicit BloomFilterVal(zeek::probabilistic::BloomFilter* bf); + explicit BloomFilterVal(probabilistic::BloomFilter* bf); ~BloomFilterVal() override; ValPtr DoClone(CloneState* state) override; - const zeek::TypePtr& Type() const + const TypePtr& Type() const { return type; } - bool Typify(zeek::TypePtr type); + bool Typify(TypePtr type); void Add(const Val* val); size_t Count(const Val* val) const; @@ -333,36 +333,36 @@ private: BloomFilterVal(const BloomFilterVal&); BloomFilterVal& operator=(const BloomFilterVal&); - zeek::TypePtr type; - zeek::detail::CompositeHash* hash; - zeek::probabilistic::BloomFilter* bloom_filter; + TypePtr type; + detail::CompositeHash* hash; + probabilistic::BloomFilter* bloom_filter; }; class CardinalityVal : public OpaqueVal { public: - explicit CardinalityVal(zeek::probabilistic::detail::CardinalityCounter*); + explicit CardinalityVal(probabilistic::detail::CardinalityCounter*); ~CardinalityVal() override; ValPtr DoClone(CloneState* state) override; void Add(const Val* val); - const zeek::TypePtr& Type() const + const TypePtr& Type() const { return type; } - bool Typify(zeek::TypePtr type); + bool Typify(TypePtr type); - zeek::probabilistic::detail::CardinalityCounter* Get() { return c; }; + probabilistic::detail::CardinalityCounter* Get() { return c; }; protected: CardinalityVal(); DECLARE_OPAQUE_VALUE(CardinalityVal) private: - zeek::TypePtr type; - zeek::detail::CompositeHash* hash; - zeek::probabilistic::detail::CardinalityCounter* c; + TypePtr type; + detail::CompositeHash* hash; + probabilistic::detail::CardinalityCounter* c; }; class ParaglobVal : public OpaqueVal { diff --git a/src/Options.cc b/src/Options.cc index fe88abcb50..a9e4f40db7 100644 --- a/src/Options.cc +++ b/src/Options.cc @@ -68,7 +68,7 @@ void Options::filter_supervised_node_options() bool fake_dns() { - return zeek::util::zeekenv("ZEEK_DNS_FAKE"); + return util::zeekenv("ZEEK_DNS_FAKE"); } extern const char* zeek_version(); @@ -123,16 +123,16 @@ void usage(const char* prog, int code) #endif fprintf(stderr, " --test | run unit tests ('--test -h' for help, only when compiling with ENABLE_ZEEK_UNIT_TESTS)\n"); - fprintf(stderr, " $ZEEKPATH | file search path (%s)\n", zeek::util::zeek_path().c_str()); - fprintf(stderr, " $ZEEK_PLUGIN_PATH | plugin search path (%s)\n", zeek::util::zeek_plugin_path()); - fprintf(stderr, " $ZEEK_PLUGIN_ACTIVATE | plugins to always activate (%s)\n", zeek::util::zeek_plugin_activate()); - fprintf(stderr, " $ZEEK_PREFIXES | prefix list (%s)\n", zeek::util::zeek_prefixes().c_str()); - fprintf(stderr, " $ZEEK_DNS_FAKE | disable DNS lookups (%s)\n", zeek::fake_dns() ? "on" : "off"); + fprintf(stderr, " $ZEEKPATH | file search path (%s)\n", util::zeek_path().c_str()); + fprintf(stderr, " $ZEEK_PLUGIN_PATH | plugin search path (%s)\n", util::zeek_plugin_path()); + fprintf(stderr, " $ZEEK_PLUGIN_ACTIVATE | plugins to always activate (%s)\n", util::zeek_plugin_activate()); + fprintf(stderr, " $ZEEK_PREFIXES | prefix list (%s)\n", util::zeek_prefixes().c_str()); + fprintf(stderr, " $ZEEK_DNS_FAKE | disable DNS lookups (%s)\n", fake_dns() ? "on" : "off"); fprintf(stderr, " $ZEEK_SEED_FILE | file to load seeds from (not set)\n"); - fprintf(stderr, " $ZEEK_LOG_SUFFIX | ASCII log file extension (.%s)\n", zeek::logging::writer::detail::Ascii::LogExt().c_str()); + fprintf(stderr, " $ZEEK_LOG_SUFFIX | ASCII log file extension (.%s)\n", logging::writer::detail::Ascii::LogExt().c_str()); fprintf(stderr, " $ZEEK_PROFILER_FILE | Output file for script execution statistics (not set)\n"); - fprintf(stderr, " $ZEEK_DISABLE_ZEEKYGEN | Disable Zeekygen documentation support (%s)\n", zeek::util::zeekenv("ZEEK_DISABLE_ZEEKYGEN") ? "set" : "not set"); - fprintf(stderr, " $ZEEK_DNS_RESOLVER | IPv4/IPv6 address of DNS resolver to use (%s)\n", zeek::util::zeekenv("ZEEK_DNS_RESOLVER") ? zeek::util::zeekenv("ZEEK_DNS_RESOLVER") : "not set, will use first IPv4 address from /etc/resolv.conf"); + fprintf(stderr, " $ZEEK_DISABLE_ZEEKYGEN | Disable Zeekygen documentation support (%s)\n", util::zeekenv("ZEEK_DISABLE_ZEEKYGEN") ? "set" : "not set"); + fprintf(stderr, " $ZEEK_DNS_RESOLVER | IPv4/IPv6 address of DNS resolver to use (%s)\n", util::zeekenv("ZEEK_DNS_RESOLVER") ? util::zeekenv("ZEEK_DNS_RESOLVER") : "not set, will use first IPv4 address from /etc/resolv.conf"); fprintf(stderr, " $ZEEK_DEBUG_LOG_STDERR | Use stderr for debug logs generated via the -B flag"); fprintf(stderr, "\n"); @@ -238,7 +238,7 @@ Options parse_cmdline(int argc, char** argv) }; char opts[256]; - zeek::util::safe_strncpy(opts, "B:e:f:G:H:I:i:j::n:p:r:s:T:t:U:w:X:CDFNPQSWabdhv", + util::safe_strncpy(opts, "B:e:f:G:H:I:i:j::n:p:r:s:T:t:U:w:X:CDFNPQSWabdhv", sizeof(opts)); #ifdef USE_PERFTOOLS_DEBUG @@ -344,9 +344,9 @@ Options parse_cmdline(int argc, char** argv) rval.pseudo_realtime = atof(optarg); break; case 'F': - if ( rval.dns_mode != zeek::detail::DNS_DEFAULT ) + if ( rval.dns_mode != detail::DNS_DEFAULT ) usage(zargs[0], 1); - rval.dns_mode = zeek::detail::DNS_FORCE; + rval.dns_mode = detail::DNS_FORCE; break; case 'G': rval.random_seed_input_file = optarg; @@ -361,9 +361,9 @@ Options parse_cmdline(int argc, char** argv) ++rval.print_plugins; break; case 'P': - if ( rval.dns_mode != zeek::detail::DNS_DEFAULT ) + if ( rval.dns_mode != detail::DNS_DEFAULT ) usage(zargs[0], 1); - rval.dns_mode = zeek::detail::DNS_PRIME; + rval.dns_mode = detail::DNS_PRIME; break; case 'Q': rval.print_execution_time = true; @@ -433,7 +433,7 @@ Options parse_cmdline(int argc, char** argv) if ( path->empty() ) return; - *path = zeek::util::detail::normalize_path(*path); + *path = util::detail::normalize_path(*path); if ( (*path)[0] == '/' || (*path)[0] == '~' ) // Absolute path @@ -442,7 +442,7 @@ Options parse_cmdline(int argc, char** argv) if ( (*path)[0] != '.' ) { // Look up file in ZEEKPATH - auto res = zeek::util::find_script_file(*path, zeek::util::zeek_path()); + auto res = util::find_script_file(*path, util::zeek_path()); if ( res.empty() ) { diff --git a/src/Options.h b/src/Options.h index 496662739f..d70e37d65c 100644 --- a/src/Options.h +++ b/src/Options.h @@ -45,7 +45,7 @@ struct Options { bool ignore_checksums = false; bool use_watchdog = false; double pseudo_realtime = 0; - zeek::detail::DNS_MgrMode dns_mode = zeek::detail::DNS_DEFAULT; + detail::DNS_MgrMode dns_mode = detail::DNS_DEFAULT; bool supervisor_mode = false; bool parse_only = false; @@ -82,7 +82,7 @@ struct Options { * @param argv argument strings (same semantics as arguments to main()) * @return the parsed command-line options */ -zeek::Options parse_cmdline(int argc, char** argv); +Options parse_cmdline(int argc, char** argv); /** * Print command-line Zeek usage information and exit. diff --git a/src/PacketDumper.cc b/src/PacketDumper.cc index 97a477b21a..117b797d3b 100644 --- a/src/PacketDumper.cc +++ b/src/PacketDumper.cc @@ -14,7 +14,7 @@ PacketDumper::PacketDumper(pcap_dumper_t* arg_pkt_dump) pkt_dump = arg_pkt_dump; if ( ! pkt_dump ) - zeek::reporter->InternalError("PacketDumper: nil dump file"); + reporter->InternalError("PacketDumper: nil dump file"); } void PacketDumper::DumpPacket(const struct pcap_pkthdr* hdr, @@ -25,7 +25,7 @@ void PacketDumper::DumpPacket(const struct pcap_pkthdr* hdr, struct pcap_pkthdr h = *hdr; h.caplen = len; if ( h.caplen > hdr->caplen ) - zeek::reporter->InternalError("bad modified caplen"); + reporter->InternalError("bad modified caplen"); pcap_dump((u_char*) pkt_dump, &h, pkt); } @@ -33,7 +33,7 @@ void PacketDumper::DumpPacket(const struct pcap_pkthdr* hdr, void PacketDumper::SortTimeStamp(struct timeval* timestamp) { - if ( zeek::util::time_compare(&last_timestamp, timestamp) > 0 ) + if ( util::time_compare(&last_timestamp, timestamp) > 0 ) *timestamp = last_timestamp; else last_timestamp = *timestamp; diff --git a/src/PacketFilter.cc b/src/PacketFilter.cc index 3e00f43d02..43e13bd32b 100644 --- a/src/PacketFilter.cc +++ b/src/PacketFilter.cc @@ -16,71 +16,71 @@ PacketFilter::PacketFilter(bool arg_default) dst_filter.SetDeleteFunction(PacketFilter::DeleteFilter); } -void PacketFilter::AddSrc(const zeek::IPAddr& src, uint32_t tcp_flags, double probability) +void PacketFilter::AddSrc(const IPAddr& src, uint32_t tcp_flags, double probability) { Filter* f = new Filter; f->tcp_flags = tcp_flags; - f->probability = probability * static_cast(zeek::util::detail::max_random()); + f->probability = probability * static_cast(util::detail::max_random()); auto prev = static_cast(src_filter.Insert(src, 128, f)); delete prev; } -void PacketFilter::AddSrc(zeek::Val* src, uint32_t tcp_flags, double probability) +void PacketFilter::AddSrc(Val* src, uint32_t tcp_flags, double probability) { Filter* f = new Filter; f->tcp_flags = tcp_flags; - f->probability = probability * static_cast(zeek::util::detail::max_random()); + f->probability = probability * static_cast(util::detail::max_random()); auto prev = static_cast(src_filter.Insert(src, f)); delete prev; } -void PacketFilter::AddDst(const zeek::IPAddr& dst, uint32_t tcp_flags, double probability) +void PacketFilter::AddDst(const IPAddr& dst, uint32_t tcp_flags, double probability) { Filter* f = new Filter; f->tcp_flags = tcp_flags; - f->probability = probability * static_cast(zeek::util::detail::max_random()); + f->probability = probability * static_cast(util::detail::max_random()); auto prev = static_cast(dst_filter.Insert(dst, 128, f)); delete prev; } -void PacketFilter::AddDst(zeek::Val* dst, uint32_t tcp_flags, double probability) +void PacketFilter::AddDst(Val* dst, uint32_t tcp_flags, double probability) { Filter* f = new Filter; f->tcp_flags = tcp_flags; - f->probability = probability * static_cast(zeek::util::detail::max_random()); + f->probability = probability * static_cast(util::detail::max_random()); auto prev = static_cast(dst_filter.Insert(dst, f)); delete prev; } -bool PacketFilter::RemoveSrc(const zeek::IPAddr& src) +bool PacketFilter::RemoveSrc(const IPAddr& src) { auto f = static_cast(src_filter.Remove(src, 128)); delete f; return f != nullptr; } -bool PacketFilter::RemoveSrc(zeek::Val* src) +bool PacketFilter::RemoveSrc(Val* src) { auto f = static_cast(src_filter.Remove(src)); delete f; return f != nullptr; } -bool PacketFilter::RemoveDst(const zeek::IPAddr& dst) +bool PacketFilter::RemoveDst(const IPAddr& dst) { auto f = static_cast(dst_filter.Remove(dst, 128)); delete f; return f != nullptr; } -bool PacketFilter::RemoveDst(zeek::Val* dst) +bool PacketFilter::RemoveDst(Val* dst) { auto f = static_cast(dst_filter.Remove(dst)); delete f; return f != nullptr; } -bool PacketFilter::Match(const zeek::IP_Hdr* ip, int len, int caplen) +bool PacketFilter::Match(const IP_Hdr* ip, int len, int caplen) { Filter* f = (Filter*) src_filter.Lookup(ip->SrcAddr(), 128); if ( f ) @@ -93,7 +93,7 @@ bool PacketFilter::Match(const zeek::IP_Hdr* ip, int len, int caplen) return default_match; } -bool PacketFilter::MatchFilter(const Filter& f, const zeek::IP_Hdr& ip, +bool PacketFilter::MatchFilter(const Filter& f, const IP_Hdr& ip, int len, int caplen) { if ( ip.NextProto() == IPPROTO_TCP && f.tcp_flags ) @@ -115,7 +115,7 @@ bool PacketFilter::MatchFilter(const Filter& f, const zeek::IP_Hdr& ip, return false; } - return zeek::util::detail::random_number() < f.probability; + return util::detail::random_number() < f.probability; } } // namespace zeek::detail diff --git a/src/PacketFilter.h b/src/PacketFilter.h index c7b892ca20..edf58a1280 100644 --- a/src/PacketFilter.h +++ b/src/PacketFilter.h @@ -18,20 +18,20 @@ public: // Drops all packets from a particular source (which may be given // as an AddrVal or a SubnetVal) which hasn't any of TCP flags set // (TH_*) with the given probability (from 0..MAX_PROB). - void AddSrc(const zeek::IPAddr& src, uint32_t tcp_flags, double probability); - void AddSrc(zeek::Val* src, uint32_t tcp_flags, double probability); - void AddDst(const zeek::IPAddr& src, uint32_t tcp_flags, double probability); - void AddDst(zeek::Val* src, uint32_t tcp_flags, double probability); + void AddSrc(const IPAddr& src, uint32_t tcp_flags, double probability); + void AddSrc(Val* src, uint32_t tcp_flags, double probability); + void AddDst(const IPAddr& src, uint32_t tcp_flags, double probability); + void AddDst(Val* src, uint32_t tcp_flags, double probability); // Removes the filter entry for the given src/dst // Returns false if filter doesn not exist. - bool RemoveSrc(const zeek::IPAddr& src); - bool RemoveSrc(zeek::Val* dst); - bool RemoveDst(const zeek::IPAddr& dst); - bool RemoveDst(zeek::Val* dst); + bool RemoveSrc(const IPAddr& src); + bool RemoveSrc(Val* dst); + bool RemoveDst(const IPAddr& dst); + bool RemoveDst(Val* dst); // Returns true if packet matches a drop filter - bool Match(const zeek::IP_Hdr* ip, int len, int caplen); + bool Match(const IP_Hdr* ip, int len, int caplen); private: struct Filter { @@ -41,7 +41,7 @@ private: static void DeleteFilter(void* data); - bool MatchFilter(const Filter& f, const zeek::IP_Hdr& ip, int len, int caplen); + bool MatchFilter(const Filter& f, const IP_Hdr& ip, int len, int caplen); bool default_match; PrefixTable src_filter; diff --git a/src/Pipe.cc b/src/Pipe.cc index d21d89967d..ae710e4603 100644 --- a/src/Pipe.cc +++ b/src/Pipe.cc @@ -7,15 +7,15 @@ #include #include -using namespace zeek::detail; +namespace zeek::detail { static void pipe_fail(int eno) { char tmp[256]; zeek::util::zeek_strerror_r(eno, tmp, sizeof(tmp)); - if ( zeek::reporter ) - zeek::reporter->FatalError("Pipe failure: %s", tmp); + if ( reporter ) + reporter->FatalError("Pipe failure: %s", tmp); else fprintf(stderr, "Pipe failure: %s", tmp); } @@ -156,3 +156,5 @@ PipePair::PipePair(int flags, int status_flags, int* fds) Pipe(flags, flags, status_flags, status_flags, fds ? fds + 2 : nullptr)} { } + +} // namespace zeek::detail diff --git a/src/PolicyFile.cc b/src/PolicyFile.cc index d833ec0211..283ca7daf0 100644 --- a/src/PolicyFile.cc +++ b/src/PolicyFile.cc @@ -34,12 +34,12 @@ namespace zeek::detail { int how_many_lines_in(const char* policy_filename) { if ( ! policy_filename ) - zeek::reporter->InternalError("NULL value passed to how_many_lines_in\n"); + reporter->InternalError("NULL value passed to how_many_lines_in\n"); FILE* throwaway = fopen(policy_filename, "r"); if ( ! throwaway ) { - zeek::detail::debug_msg("No such policy file: %s.\n", policy_filename); + debug_msg("No such policy file: %s.\n", policy_filename); return -1; } @@ -53,7 +53,7 @@ int how_many_lines_in(const char* policy_filename) match = policy_files.find(policy_filename); if ( match == policy_files.end() ) { - zeek::detail::debug_msg("Policy file %s was not loaded.\n", policy_filename); + debug_msg("Policy file %s was not loaded.\n", policy_filename); return -1; } } @@ -71,14 +71,14 @@ bool LoadPolicyFileText(const char* policy_filename) if ( ! f ) { - zeek::detail::debug_msg("No such policy file: %s.\n", policy_filename); + debug_msg("No such policy file: %s.\n", policy_filename); return false; } PolicyFile* pf = new PolicyFile; if ( policy_files.find(policy_filename) != policy_files.end() ) - zeek::detail::debug_msg("Policy file %s already loaded\n", policy_filename); + debug_msg("Policy file %s already loaded\n", policy_filename); policy_files.insert(PolicyFileMap::value_type(policy_filename, pf)); @@ -86,8 +86,8 @@ bool LoadPolicyFileText(const char* policy_filename) if ( fstat(fileno(f), &st) != 0 ) { char buf[256]; - zeek::util::zeek_strerror_r(errno, buf, sizeof(buf)); - zeek::reporter->Error("fstat failed on %s: %s", policy_filename, buf); + util::zeek_strerror_r(errno, buf, sizeof(buf)); + reporter->Error("fstat failed on %s: %s", policy_filename, buf); fclose(f); return false; } @@ -99,7 +99,7 @@ bool LoadPolicyFileText(const char* policy_filename) // (probably fine with UTF-8) pf->filedata = new char[size+1]; if ( fread(pf->filedata, size, 1, f) != 1 ) - zeek::reporter->InternalError("Failed to fread() file data"); + reporter->InternalError("Failed to fread() file data"); pf->filedata[size] = 0; fclose(f); @@ -131,7 +131,7 @@ bool PrintLines(const char* policy_filename, unsigned int start_line, FILE* throwaway = fopen(policy_filename, "r"); if ( ! throwaway ) { - zeek::detail::debug_msg("No such policy file: %s.\n", policy_filename); + debug_msg("No such policy file: %s.\n", policy_filename); return false; } @@ -145,7 +145,7 @@ bool PrintLines(const char* policy_filename, unsigned int start_line, match = policy_files.find(policy_filename); if ( match == policy_files.end() ) { - zeek::detail::debug_msg("Policy file %s was not loaded.\n", policy_filename); + debug_msg("Policy file %s was not loaded.\n", policy_filename); return false; } } @@ -157,7 +157,7 @@ bool PrintLines(const char* policy_filename, unsigned int start_line, if ( start_line > pf->lines.size() ) { - zeek::detail::debug_msg("Line number %d out of range; %s has %d lines\n", + debug_msg("Line number %d out of range; %s has %d lines\n", start_line, policy_filename, int(pf->lines.size())); return false; } @@ -168,10 +168,10 @@ bool PrintLines(const char* policy_filename, unsigned int start_line, for ( unsigned int i = 0; i < how_many_lines; ++i ) { if ( show_numbers ) - zeek::detail::debug_msg("%d\t", i + start_line); + debug_msg("%d\t", i + start_line); const char* line = pf->lines[start_line + i - 1]; - zeek::detail::debug_msg("%s\n", line); + debug_msg("%s\n", line); } return true; diff --git a/src/PrefixTable.cc b/src/PrefixTable.cc index 052baa3da4..684cbce435 100644 --- a/src/PrefixTable.cc +++ b/src/PrefixTable.cc @@ -4,9 +4,9 @@ namespace zeek::detail { -prefix_t* PrefixTable::MakePrefix(const zeek::IPAddr& addr, int width) +prefix_t* PrefixTable::MakePrefix(const IPAddr& addr, int width) { - prefix_t* prefix = (prefix_t*) zeek::util::safe_malloc(sizeof(prefix_t)); + prefix_t* prefix = (prefix_t*) util::safe_malloc(sizeof(prefix_t)); addr.CopyIPv6(&prefix->add.sin6); prefix->family = AF_INET6; @@ -16,12 +16,13 @@ prefix_t* PrefixTable::MakePrefix(const zeek::IPAddr& addr, int width) return prefix; } -zeek::IPPrefix PrefixTable::PrefixToIPPrefix(prefix_t* prefix) +IPPrefix PrefixTable::PrefixToIPPrefix(prefix_t* prefix) { - return zeek::IPPrefix(zeek::IPAddr(IPv6, reinterpret_cast(&prefix->add.sin6), zeek::IPAddr::Network), prefix->bitlen, true); + return IPPrefix(IPAddr(IPv6, reinterpret_cast(&prefix->add.sin6), + IPAddr::Network), prefix->bitlen, true); } -void* PrefixTable::Insert(const zeek::IPAddr& addr, int width, void* data) +void* PrefixTable::Insert(const IPAddr& addr, int width, void* data) { prefix_t* prefix = MakePrefix(addr, width); patricia_node_t* node = patricia_lookup(tree, prefix); @@ -29,7 +30,7 @@ void* PrefixTable::Insert(const zeek::IPAddr& addr, int width, void* data) if ( ! node ) { - zeek::reporter->InternalWarning("Cannot create node in patricia tree"); + reporter->InternalWarning("Cannot create node in patricia tree"); return nullptr; } @@ -42,32 +43,32 @@ void* PrefixTable::Insert(const zeek::IPAddr& addr, int width, void* data) return old; } -void* PrefixTable::Insert(const zeek::Val* value, void* data) +void* PrefixTable::Insert(const Val* value, void* data) { // [elem] -> elem - if ( value->GetType()->Tag() == zeek::TYPE_LIST && + if ( value->GetType()->Tag() == TYPE_LIST && value->AsListVal()->Length() == 1 ) value = value->AsListVal()->Idx(0).get(); switch ( value->GetType()->Tag() ) { - case zeek::TYPE_ADDR: + case TYPE_ADDR: return Insert(value->AsAddr(), 128, data); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: return Insert(value->AsSubNet().Prefix(), value->AsSubNet().LengthIPv6(), data); break; default: - zeek::reporter->InternalWarning("Wrong index type for PrefixTable"); + reporter->InternalWarning("Wrong index type for PrefixTable"); return nullptr; } } -std::list> PrefixTable::FindAll(const zeek::IPAddr& addr, int width) const +std::list> PrefixTable::FindAll(const IPAddr& addr, int width) const { - std::list> out; + std::list> out; prefix_t* prefix = MakePrefix(addr, width); int elems = 0; @@ -83,12 +84,12 @@ std::list> PrefixTable::FindAll(const zeek::IPA return out; } -std::list> PrefixTable::FindAll(const zeek::SubNetVal* value) const +std::list> PrefixTable::FindAll(const SubNetVal* value) const { return FindAll(value->AsSubNet().Prefix(), value->AsSubNet().LengthIPv6()); } -void* PrefixTable::Lookup(const zeek::IPAddr& addr, int width, bool exact) const +void* PrefixTable::Lookup(const IPAddr& addr, int width, bool exact) const { prefix_t* prefix = MakePrefix(addr, width); patricia_node_t* node = @@ -102,31 +103,31 @@ void* PrefixTable::Lookup(const zeek::IPAddr& addr, int width, bool exact) const return node ? node->data : nullptr; } -void* PrefixTable::Lookup(const zeek::Val* value, bool exact) const +void* PrefixTable::Lookup(const Val* value, bool exact) const { // [elem] -> elem - if ( value->GetType()->Tag() == zeek::TYPE_LIST && + if ( value->GetType()->Tag() == TYPE_LIST && value->AsListVal()->Length() == 1 ) value = value->AsListVal()->Idx(0).get(); switch ( value->GetType()->Tag() ) { - case zeek::TYPE_ADDR: + case TYPE_ADDR: return Lookup(value->AsAddr(), 128, exact); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: return Lookup(value->AsSubNet().Prefix(), value->AsSubNet().LengthIPv6(), exact); break; default: - zeek::reporter->InternalWarning("Wrong index type %d for PrefixTable", - value->GetType()->Tag()); + reporter->InternalWarning("Wrong index type %d for PrefixTable", + value->GetType()->Tag()); return nullptr; } } -void* PrefixTable::Remove(const zeek::IPAddr& addr, int width) +void* PrefixTable::Remove(const IPAddr& addr, int width) { prefix_t* prefix = MakePrefix(addr, width); patricia_node_t* node = patricia_search_exact(tree, prefix); @@ -141,25 +142,25 @@ void* PrefixTable::Remove(const zeek::IPAddr& addr, int width) return old; } -void* PrefixTable::Remove(const zeek::Val* value) +void* PrefixTable::Remove(const Val* value) { // [elem] -> elem - if ( value->GetType()->Tag() == zeek::TYPE_LIST && + if ( value->GetType()->Tag() == TYPE_LIST && value->AsListVal()->Length() == 1 ) value = value->AsListVal()->Idx(0).get(); switch ( value->GetType()->Tag() ) { - case zeek::TYPE_ADDR: + case TYPE_ADDR: return Remove(value->AsAddr(), 128); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: return Remove(value->AsSubNet().Prefix(), value->AsSubNet().LengthIPv6()); break; default: - zeek::reporter->InternalWarning("Wrong index type for PrefixTable"); + reporter->InternalWarning("Wrong index type for PrefixTable"); return nullptr; } } diff --git a/src/PrefixTable.h b/src/PrefixTable.h index 80a89efa64..c6989378f7 100644 --- a/src/PrefixTable.h +++ b/src/PrefixTable.h @@ -29,24 +29,24 @@ public: // Addr in network byte order. If data is zero, acts like a set. // Returns ptr to old data if already existing. // For existing items without data, returns non-nil if found. - void* Insert(const zeek::IPAddr& addr, int width, void* data = nullptr); + void* Insert(const IPAddr& addr, int width, void* data = nullptr); // Value may be addr or subnet. - void* Insert(const zeek::Val* value, void* data = nullptr); + void* Insert(const Val* value, void* data = nullptr); // Returns nil if not found, pointer to data otherwise. // For items without data, returns non-nil if found. // If exact is false, performs exact rather than longest-prefix match. - void* Lookup(const zeek::IPAddr& addr, int width, bool exact = false) const; - void* Lookup(const zeek::Val* value, bool exact = false) const; + void* Lookup(const IPAddr& addr, int width, bool exact = false) const; + void* Lookup(const Val* value, bool exact = false) const; // Returns list of all found matches or empty list otherwise. - std::list> FindAll(const zeek::IPAddr& addr, int width) const; - std::list> FindAll(const zeek::SubNetVal* value) const; + std::list> FindAll(const IPAddr& addr, int width) const; + std::list> FindAll(const SubNetVal* value) const; // Returns pointer to data or nil if not found. - void* Remove(const zeek::IPAddr& addr, int width); - void* Remove(const zeek::Val* value); + void* Remove(const IPAddr& addr, int width); + void* Remove(const Val* value); void Clear() { Clear_Patricia(tree, delete_function); } @@ -57,8 +57,8 @@ public: void* GetNext(iterator* i); private: - static prefix_t* MakePrefix(const zeek::IPAddr& addr, int width); - static zeek::IPPrefix PrefixToIPPrefix(prefix_t* p); + static prefix_t* MakePrefix(const IPAddr& addr, int width); + static IPPrefix PrefixToIPPrefix(prefix_t* p); patricia_tree_t* tree; data_fn_t delete_function; diff --git a/src/PriorityQueue.cc b/src/PriorityQueue.cc index 61d8776aeb..461989074d 100644 --- a/src/PriorityQueue.cc +++ b/src/PriorityQueue.cc @@ -51,7 +51,7 @@ PQ_Element* PriorityQueue::Remove(PQ_Element* e) PQ_Element* e2 = Remove(); if ( e != e2 ) - zeek::reporter->InternalError("inconsistency in PriorityQueue::Remove"); + reporter->InternalError("inconsistency in PriorityQueue::Remove"); return e2; } diff --git a/src/RE.cc b/src/RE.cc index 1e1bcadc2b..be9996fd76 100644 --- a/src/RE.cc +++ b/src/RE.cc @@ -135,7 +135,7 @@ bool Specific_RE_Matcher::Compile(bool lazy) if ( parse_status ) { - zeek::reporter->Error("error compiling pattern /%s/", pattern_text); + reporter->Error("error compiling pattern /%s/", pattern_text); Unref(nfa); nfa = nullptr; return false; @@ -157,7 +157,7 @@ bool Specific_RE_Matcher::Compile(bool lazy) bool Specific_RE_Matcher::CompileSet(const string_list& set, const int_list& idx) { if ( (size_t)set.length() != idx.size() ) - zeek::reporter->InternalError("compileset: lengths of sets differ"); + reporter->InternalError("compileset: lengths of sets differ"); rem = this; @@ -171,7 +171,7 @@ bool Specific_RE_Matcher::CompileSet(const string_list& set, const int_list& idx if ( parse_status ) { - zeek::reporter->Error("error compiling pattern /%s/", set[i]); + reporter->Error("error compiling pattern /%s/", set[i]); if ( set_nfa && set_nfa != nfa ) Unref(set_nfa); @@ -215,7 +215,7 @@ bool Specific_RE_Matcher::MatchAll(const char* s) return MatchAll((const u_char*)(s), strlen(s)); } -bool Specific_RE_Matcher::MatchAll(const zeek::String* s) +bool Specific_RE_Matcher::MatchAll(const String* s) { // s->Len() does not include '\0'. return MatchAll(s->Bytes(), s->Len()); @@ -226,7 +226,7 @@ int Specific_RE_Matcher::Match(const char* s) return Match((const u_char*)(s), strlen(s)); } -int Specific_RE_Matcher::Match(const zeek::String* s) +int Specific_RE_Matcher::Match(const String* s) { return Match(s->Bytes(), s->Len()); } @@ -236,7 +236,7 @@ int Specific_RE_Matcher::LongestMatch(const char* s) return LongestMatch((const u_char*)(s), strlen(s)); } -int Specific_RE_Matcher::LongestMatch(const zeek::String* s) +int Specific_RE_Matcher::LongestMatch(const String* s) { return LongestMatch(s->Bytes(), s->Len()); } @@ -423,21 +423,21 @@ unsigned int Specific_RE_Matcher::MemoryAllocation() const for ( int i = 0; i < ccl_list.length(); ++i ) size += ccl_list[i]->MemoryAllocation(); - size += zeek::util::pad_size(sizeof(CCL*) * ccl_dict.size()); + size += util::pad_size(sizeof(CCL*) * ccl_dict.size()); for ( const auto& entry : ccl_dict ) { - size += padded_sizeof(std::string) + zeek::util::pad_size(sizeof(std::string::value_type) * entry.first.size()); + size += padded_sizeof(std::string) + util::pad_size(sizeof(std::string::value_type) * entry.first.size()); size += entry.second->MemoryAllocation(); } for ( const auto& entry : defs ) { - size += padded_sizeof(std::string) + zeek::util::pad_size(sizeof(std::string::value_type) * entry.first.size()); - size += padded_sizeof(std::string) + zeek::util::pad_size(sizeof(std::string::value_type) * entry.second.size()); + size += padded_sizeof(std::string) + util::pad_size(sizeof(std::string::value_type) * entry.first.size()); + size += padded_sizeof(std::string) + util::pad_size(sizeof(std::string::value_type) * entry.second.size()); } return size + padded_sizeof(*this) - + (pattern_text ? zeek::util::pad_size(strlen(pattern_text) + 1) : 0) + + (pattern_text ? util::pad_size(strlen(pattern_text) + 1) : 0) + ccl_list.MemoryAllocation() - padded_sizeof(ccl_list) + equiv_class.Size() - padded_sizeof(EquivClass) + (dfa ? dfa->MemoryAllocation() : 0) // this is ref counted; consider the bytes here? @@ -479,23 +479,23 @@ RE_Matcher* RE_Matcher_disjunction(const RE_Matcher* re1, const RE_Matcher* re2) RE_Matcher::RE_Matcher() { - re_anywhere = new detail::Specific_RE_Matcher(zeek::detail::MATCH_ANYWHERE); - re_exact = new detail::Specific_RE_Matcher(zeek::detail::MATCH_EXACTLY); + re_anywhere = new detail::Specific_RE_Matcher(detail::MATCH_ANYWHERE); + re_exact = new detail::Specific_RE_Matcher(detail::MATCH_EXACTLY); } RE_Matcher::RE_Matcher(const char* pat) { - re_anywhere = new detail::Specific_RE_Matcher(zeek::detail::MATCH_ANYWHERE); - re_exact = new detail::Specific_RE_Matcher(zeek::detail::MATCH_EXACTLY); + re_anywhere = new detail::Specific_RE_Matcher(detail::MATCH_ANYWHERE); + re_exact = new detail::Specific_RE_Matcher(detail::MATCH_EXACTLY); AddPat(pat); } RE_Matcher::RE_Matcher(const char* exact_pat, const char* anywhere_pat) { - re_anywhere = new detail::Specific_RE_Matcher(zeek::detail::MATCH_ANYWHERE); + re_anywhere = new detail::Specific_RE_Matcher(detail::MATCH_ANYWHERE); re_anywhere->SetPat(anywhere_pat); - re_exact = new detail::Specific_RE_Matcher(zeek::detail::MATCH_EXACTLY); + re_exact = new detail::Specific_RE_Matcher(detail::MATCH_EXACTLY); re_exact->SetPat(exact_pat); } diff --git a/src/RE.h b/src/RE.h index 6f9d4d7dd0..449a9a6e42 100644 --- a/src/RE.h +++ b/src/RE.h @@ -32,7 +32,7 @@ namespace detail { extern int case_insensitive; extern CCL* curr_ccl; -extern zeek::detail::NFA_Machine* nfa; +extern NFA_Machine* nfa; extern Specific_RE_Matcher* rem; extern const char* RE_parse_input; @@ -43,7 +43,7 @@ using AcceptIdx = int; using AcceptingSet = std::set; using MatchPos = uint64_t; using AcceptingMatchSet = std::map; -using string_list = zeek::name_list; +using string_list = name_list; enum match_type { MATCH_ANYWHERE, MATCH_EXACTLY }; @@ -59,7 +59,7 @@ public: void MakeCaseInsensitive(); - void SetPat(const char* pat) { pattern_text = zeek::util::copy_string(pat); } + void SetPat(const char* pat) { pattern_text = util::copy_string(pat); } bool Compile(bool lazy = false); @@ -88,7 +88,7 @@ public: void ConvertCCLs(); bool MatchAll(const char* s); - bool MatchAll(const zeek::String* s); + bool MatchAll(const String* s); // Compiles a set of regular expressions simultaniously. // 'idx' contains indizes associated with the expressions. @@ -101,17 +101,17 @@ public: // if the pattern matches empty strings, matching continues // in an attempt to match at least one character. int Match(const char* s); - int Match(const zeek::String* s); + int Match(const String* s); int LongestMatch(const char* s); - int LongestMatch(const zeek::String* s); + int LongestMatch(const String* s); int LongestMatch(const u_char* bv, int n); EquivClass* EC() { return &equiv_class; } const char* PatternText() const { return pattern_text; } - zeek::detail::DFA_Machine* DFA() const { return dfa; } + DFA_Machine* DFA() const { return dfa; } void Dump(FILE* f); @@ -135,10 +135,10 @@ protected: std::map defs; std::map ccl_dict; - zeek::PList ccl_list; + PList ccl_list; EquivClass equiv_class; int* ecs; - zeek::detail::DFA_Machine* dfa; + DFA_Machine* dfa; CCL* any_ccl; AcceptingSet* accepted; }; @@ -173,11 +173,11 @@ public: void AddMatches(const AcceptingSet& as, MatchPos position); protected: - zeek::detail::DFA_Machine* dfa; + DFA_Machine* dfa; int* ecs; AcceptingMatchSet accepted_matches; - zeek::detail::DFA_State* current_state; + DFA_State* current_state; int current_pos; }; @@ -203,7 +203,7 @@ public: // Returns true if s exactly matches the pattern, false otherwise. bool MatchExactly(const char* s) { return re_exact->MatchAll(s); } - bool MatchExactly(const zeek::String* s) + bool MatchExactly(const String* s) { return re_exact->MatchAll(s); } // Returns the position in s just beyond where the first match @@ -212,14 +212,14 @@ public: // in an attempt to match at least one character. int MatchAnywhere(const char* s) { return re_anywhere->Match(s); } - int MatchAnywhere(const zeek::String* s) + int MatchAnywhere(const String* s) { return re_anywhere->Match(s); } // Note: it matches the *longest* prefix and returns the // length of matched prefix. It returns -1 on mismatch. int MatchPrefix(const char* s) { return re_exact->LongestMatch(s); } - int MatchPrefix(const zeek::String* s) + int MatchPrefix(const String* s) { return re_exact->LongestMatch(s); } int MatchPrefix(const u_char* s, int n) { return re_exact->LongestMatch(s, n); } diff --git a/src/Reassem.cc b/src/Reassem.cc index f9c5983e3d..cd30d7d090 100644 --- a/src/Reassem.cc +++ b/src/Reassem.cc @@ -371,7 +371,7 @@ uint64_t Reassembler::TotalSize() const return block_list.DataSize() + old_block_list.DataSize(); } -void Reassembler::Describe(zeek::ODesc* d) const +void Reassembler::Describe(ODesc* d) const { d->Add("reassembler"); } diff --git a/src/Reassem.h b/src/Reassem.h index 4cbe6dce66..0c713bf60a 100644 --- a/src/Reassem.h +++ b/src/Reassem.h @@ -252,7 +252,7 @@ private: DataBlockMap block_map; }; -class Reassembler : public zeek::Obj { +class Reassembler : public Obj { public: Reassembler(uint64_t init_seq, ReassemblerType reassem_type = REASSEM_UNKNOWN); ~Reassembler() override {} @@ -280,7 +280,7 @@ public: uint64_t TotalSize() const; // number of bytes buffered up - void Describe(zeek::ODesc* d) const override; + void Describe(ODesc* d) const override; // Sum over all data buffered in some reassembler. static uint64_t TotalMemoryAllocation() { return total_size; } diff --git a/src/Reporter.cc b/src/Reporter.cc index f7aca794fe..bc20ff0850 100644 --- a/src/Reporter.cc +++ b/src/Reporter.cc @@ -66,18 +66,18 @@ Reporter::~Reporter() void Reporter::InitOptions() { - info_to_stderr = zeek::id::find_val("Reporter::info_to_stderr")->AsBool(); - warnings_to_stderr = zeek::id::find_val("Reporter::warnings_to_stderr")->AsBool(); - errors_to_stderr = zeek::id::find_val("Reporter::errors_to_stderr")->AsBool(); - weird_sampling_rate = zeek::id::find_val("Weird::sampling_rate")->AsCount(); - weird_sampling_threshold = zeek::id::find_val("Weird::sampling_threshold")->AsCount(); - weird_sampling_duration = zeek::id::find_val("Weird::sampling_duration")->AsInterval(); - auto wl_val = zeek::id::find_val("Weird::sampling_whitelist")->AsTableVal(); + info_to_stderr = id::find_val("Reporter::info_to_stderr")->AsBool(); + warnings_to_stderr = id::find_val("Reporter::warnings_to_stderr")->AsBool(); + errors_to_stderr = id::find_val("Reporter::errors_to_stderr")->AsBool(); + weird_sampling_rate = id::find_val("Weird::sampling_rate")->AsCount(); + weird_sampling_threshold = id::find_val("Weird::sampling_threshold")->AsCount(); + weird_sampling_duration = id::find_val("Weird::sampling_duration")->AsInterval(); + auto wl_val = id::find_val("Weird::sampling_whitelist")->AsTableVal(); auto wl_table = wl_val->AsTable(); - zeek::detail::HashKey* k; - zeek::IterCookie* c = wl_table->InitForIteration(); - zeek::TableEntryVal* v; + detail::HashKey* k; + IterCookie* c = wl_table->InitForIteration(); + TableEntryVal* v; while ( (v = wl_table->NextEntry(k, c)) ) { @@ -126,7 +126,7 @@ void Reporter::FatalError(const char* fmt, ...) va_end(ap); - zeek::util::detail::set_processing_status("TERMINATED", "fatal_error"); + util::detail::set_processing_status("TERMINATED", "fatal_error"); fflush(stderr); fflush(stdout); _exit(1); @@ -142,11 +142,11 @@ void Reporter::FatalErrorWithCore(const char* fmt, ...) va_end(ap); - zeek::util::detail::set_processing_status("TERMINATED", "fatal_error"); + util::detail::set_processing_status("TERMINATED", "fatal_error"); abort(); } -void Reporter::ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...) +void Reporter::ExprRuntimeError(const detail::Expr* expr, const char* fmt, ...) { ++errors; @@ -168,7 +168,7 @@ void Reporter::ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, throw InterpreterException(); } -void Reporter::RuntimeError(const zeek::detail::Location* location, const char* fmt, ...) +void Reporter::RuntimeError(const detail::Location* location, const char* fmt, ...) { ++errors; PushLocation(location); @@ -195,11 +195,11 @@ void Reporter::InternalError(const char* fmt, ...) va_end(ap); - zeek::util::detail::set_processing_status("TERMINATED", "internal_error"); + util::detail::set_processing_status("TERMINATED", "internal_error"); abort(); } -void Reporter::AnalyzerError(zeek::analyzer::Analyzer* a, const char* fmt, ...) +void Reporter::AnalyzerError(analyzer::Analyzer* a, const char* fmt, ...) { if ( a ) a->SetSkip(true); @@ -226,7 +226,7 @@ void Reporter::InternalWarning(const char* fmt, ...) void Reporter::Syslog(const char* fmt, ...) { - if ( zeek::run_state::reading_traces ) + if ( run_state::reading_traces ) return; va_list ap; @@ -249,45 +249,45 @@ void Reporter::UpdateWeirdStats(const char* name) ++weird_count_by_type[name]; } -class NetWeirdTimer final : public zeek::detail::Timer { +class NetWeirdTimer final : public detail::Timer { public: NetWeirdTimer(double t, const char* name, double timeout) - : zeek::detail::Timer(t + timeout, zeek::detail::TIMER_NET_WEIRD_EXPIRE), + : detail::Timer(t + timeout, detail::TIMER_NET_WEIRD_EXPIRE), weird_name(name) {} void Dispatch(double t, bool is_expire) override - { zeek::reporter->ResetNetWeird(weird_name); } + { reporter->ResetNetWeird(weird_name); } std::string weird_name; }; -class FlowWeirdTimer final : public zeek::detail::Timer { +class FlowWeirdTimer final : public detail::Timer { public: - using IPPair = std::pair; + using IPPair = std::pair; FlowWeirdTimer(double t, IPPair p, double timeout) - : zeek::detail::Timer(t + timeout, zeek::detail::TIMER_FLOW_WEIRD_EXPIRE), + : detail::Timer(t + timeout, detail::TIMER_FLOW_WEIRD_EXPIRE), endpoints(std::move(p)) {} void Dispatch(double t, bool is_expire) override - { zeek::reporter->ResetFlowWeird(endpoints.first, endpoints.second); } + { reporter->ResetFlowWeird(endpoints.first, endpoints.second); } IPPair endpoints; }; -class ConnTupleWeirdTimer final : public zeek::detail::Timer { +class ConnTupleWeirdTimer final : public detail::Timer { public: using ConnTuple = Reporter::ConnTuple; ConnTupleWeirdTimer(double t, ConnTuple id, double timeout) - : zeek::detail::Timer(t + timeout, zeek::detail::TIMER_CONN_TUPLE_WEIRD_EXPIRE), + : detail::Timer(t + timeout, detail::TIMER_CONN_TUPLE_WEIRD_EXPIRE), conn_id(std::move(id)) {} void Dispatch(double t, bool is_expire) override - { zeek::reporter->ResetExpiredConnWeird(conn_id); } + { reporter->ResetExpiredConnWeird(conn_id); } ConnTuple conn_id; }; @@ -297,7 +297,7 @@ void Reporter::ResetNetWeird(const std::string& name) net_weird_state.erase(name); } -void Reporter::ResetFlowWeird(const zeek::IPAddr& orig, const zeek::IPAddr& resp) +void Reporter::ResetFlowWeird(const IPAddr& orig, const IPAddr& resp) { flow_weird_state.erase(std::make_pair(orig, resp)); } @@ -313,8 +313,8 @@ bool Reporter::PermitNetWeird(const char* name) ++count; if ( count == 1 ) - zeek::detail::timer_mgr->Add(new NetWeirdTimer(zeek::run_state::network_time, name, - weird_sampling_duration)); + detail::timer_mgr->Add(new NetWeirdTimer(run_state::network_time, name, + weird_sampling_duration)); if ( count <= weird_sampling_threshold ) return true; @@ -327,14 +327,14 @@ bool Reporter::PermitNetWeird(const char* name) } bool Reporter::PermitFlowWeird(const char* name, - const zeek::IPAddr& orig, const zeek::IPAddr& resp) + const IPAddr& orig, const IPAddr& resp) { auto endpoints = std::make_pair(orig, resp); auto& map = flow_weird_state[endpoints]; if ( map.empty() ) - zeek::detail::timer_mgr->Add(new FlowWeirdTimer(zeek::run_state::network_time, endpoints, - weird_sampling_duration)); + detail::timer_mgr->Add(new FlowWeirdTimer(run_state::network_time, endpoints, + weird_sampling_duration)); auto& count = map[name]; ++count; @@ -349,7 +349,7 @@ bool Reporter::PermitFlowWeird(const char* name, return false; } -bool Reporter::PermitExpiredConnWeird(const char* name, const zeek::RecordVal& conn_id) +bool Reporter::PermitExpiredConnWeird(const char* name, const RecordVal& conn_id) { auto conn_tuple = std::make_tuple(conn_id.GetField("orig_h")->AsAddr(), conn_id.GetField("resp_h")->AsAddr(), @@ -360,9 +360,9 @@ bool Reporter::PermitExpiredConnWeird(const char* name, const zeek::RecordVal& c auto& map = expired_conn_weird_state[conn_tuple]; if ( map.empty() ) - zeek::detail::timer_mgr->Add(new ConnTupleWeirdTimer(zeek::run_state::network_time, - std::move(conn_tuple), - weird_sampling_duration)); + detail::timer_mgr->Add(new ConnTupleWeirdTimer(run_state::network_time, + std::move(conn_tuple), + weird_sampling_duration)); auto& count = map[name]; ++count; @@ -388,7 +388,7 @@ void Reporter::Weird(const char* name, const char* addl) return; } - WeirdHelper(net_weird, {new zeek::StringVal(addl)}, "%s", name); + WeirdHelper(net_weird, {new StringVal(addl)}, "%s", name); } void Reporter::Weird(file_analysis::File* f, const char* name, const char* addl) @@ -402,7 +402,7 @@ void Reporter::Weird(file_analysis::File* f, const char* name, const char* addl) return; } - WeirdHelper(file_weird, {f->ToVal()->Ref(), new zeek::StringVal(addl)}, + WeirdHelper(file_weird, {f->ToVal()->Ref(), new StringVal(addl)}, "%s", name); } @@ -417,11 +417,11 @@ void Reporter::Weird(Connection* conn, const char* name, const char* addl) return; } - WeirdHelper(conn_weird, {conn->ConnVal()->Ref(), new zeek::StringVal(addl)}, + WeirdHelper(conn_weird, {conn->ConnVal()->Ref(), new StringVal(addl)}, "%s", name); } -void Reporter::Weird(zeek::RecordValPtr conn_id, zeek::StringValPtr uid, +void Reporter::Weird(RecordValPtr conn_id, StringValPtr uid, const char* name, const char* addl) { UpdateWeirdStats(name); @@ -433,11 +433,11 @@ void Reporter::Weird(zeek::RecordValPtr conn_id, zeek::StringValPtr uid, } WeirdHelper(expired_conn_weird, - {conn_id.release(), uid.release(), new zeek::StringVal(addl)}, + {conn_id.release(), uid.release(), new StringVal(addl)}, "%s", name); } -void Reporter::Weird(const zeek::IPAddr& orig, const zeek::IPAddr& resp, const char* name, const char* addl) +void Reporter::Weird(const IPAddr& orig, const IPAddr& resp, const char* name, const char* addl) { UpdateWeirdStats(name); @@ -448,7 +448,7 @@ void Reporter::Weird(const zeek::IPAddr& orig, const zeek::IPAddr& resp, const c } WeirdHelper(flow_weird, - {new zeek::AddrVal(orig), new zeek::AddrVal(resp), new zeek::StringVal(addl)}, + {new AddrVal(orig), new AddrVal(resp), new StringVal(addl)}, "%s", name); } @@ -473,11 +473,11 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out, { ODesc d; - std::pair locs = locations.back(); + std::pair locs = locations.back(); if ( locs.first ) { - if ( locs.first != &zeek::detail::no_location ) + if ( locs.first != &detail::no_location ) locs.first->Describe(&d); else @@ -487,7 +487,7 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out, { d.Add(" and "); - if ( locs.second != &zeek::detail::no_location ) + if ( locs.second != &detail::no_location ) locs.second->Describe(&d); else @@ -558,29 +558,29 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out, auto vl_size = 1 + (bool)time + (bool)location + (bool)conn + (addl ? addl->length() : 0); - zeek::Args vl; + Args vl; vl.reserve(vl_size); if ( time ) - vl.emplace_back(zeek::make_intrusive( - zeek::run_state::network_time ? zeek::run_state::network_time : zeek::util::current_time())); + vl.emplace_back(make_intrusive( + run_state::network_time ? run_state::network_time : util::current_time())); - vl.emplace_back(zeek::make_intrusive(buffer)); + vl.emplace_back(make_intrusive(buffer)); if ( location ) - vl.emplace_back(zeek::make_intrusive(loc_str.c_str())); + vl.emplace_back(make_intrusive(loc_str.c_str())); if ( conn ) vl.emplace_back(conn->ConnVal()); if ( addl ) for ( auto v : *addl ) - vl.emplace_back(zeek::AdoptRef{}, v); + vl.emplace_back(AdoptRef{}, v); if ( conn ) conn->EnqueueEvent(event, nullptr, std::move(vl)); else - zeek::event_mgr.Enqueue(event, std::move(vl)); + event_mgr.Enqueue(event, std::move(vl)); } else { @@ -595,10 +595,10 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out, { std::string s = ""; - if ( zeek::run_state::zeek_start_network_time != 0.0 ) + if ( run_state::zeek_start_network_time != 0.0 ) { char tmp[32]; - snprintf(tmp, 32, "%.6f", zeek::run_state::network_time); + snprintf(tmp, 32, "%.6f", run_state::network_time); s += std::string(tmp) + " "; } diff --git a/src/Reporter.h b/src/Reporter.h index 863ea2f9d1..2cf5cc512b 100644 --- a/src/Reporter.h +++ b/src/Reporter.h @@ -28,8 +28,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Reporter, zeek); namespace zeek { template class IntrusivePtr; -using RecordValPtr = zeek::IntrusivePtr; -using StringValPtr = zeek::IntrusivePtr; +using RecordValPtr = IntrusivePtr; +using StringValPtr = IntrusivePtr; // One cannot raise this exception directly, go through the // Reporter's methods instead. @@ -50,8 +50,8 @@ protected: class Reporter { public: - using IPPair = std::pair; - using ConnTuple = std::tuple; + using IPPair = std::pair; + using ConnTuple = std::tuple; using WeirdCountMap = std::unordered_map; using WeirdFlowMap = std::map; using WeirdConnTupleMap = std::map; @@ -87,20 +87,20 @@ public: // Report a runtime error in evaluating a Bro script expression. This // function will not return but raise an InterpreterException. - [[noreturn]] void ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4))); + [[noreturn]] void ExprRuntimeError(const detail::Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4))); // Report a runtime error in evaluating a Bro script expression. This // function will not return but raise an InterpreterException. - [[noreturn]] void RuntimeError(const zeek::detail::Location* location, const char* fmt, ...) __attribute__((format(printf, 3, 4))); + [[noreturn]] void RuntimeError(const detail::Location* location, const char* fmt, ...) __attribute__((format(printf, 3, 4))); // Report a traffic weirdness, i.e., an unexpected protocol situation // that may lead to incorrectly processing a connnection. void Weird(const char* name, const char* addl = ""); // Raises net_weird(). void Weird(file_analysis::File* f, const char* name, const char* addl = ""); // Raises file_weird(). void Weird(Connection* conn, const char* name, const char* addl = ""); // Raises conn_weird(). - void Weird(zeek::RecordValPtr conn_id, zeek::StringValPtr uid, + void Weird(RecordValPtr conn_id, StringValPtr uid, const char* name, const char* addl = ""); // Raises expired_conn_weird(). - void Weird(const zeek::IPAddr& orig, const zeek::IPAddr& resp, const char* name, const char* addl = ""); // Raises flow_weird(). + void Weird(const IPAddr& orig, const IPAddr& resp, const char* name, const char* addl = ""); // Raises flow_weird(). // Syslog a message. This methods does nothing if we're running // offline from a trace. @@ -116,7 +116,7 @@ public: // Report an analyzer error. That analyzer will be set to not process // any further input, but Bro otherwise continues normally. - void AnalyzerError(zeek::analyzer::Analyzer* a, const char* fmt, ...) __attribute__((format(printf, 3, 4)));; + void AnalyzerError(analyzer::Analyzer* a, const char* fmt, ...) __attribute__((format(printf, 3, 4)));; // Toggle whether non-fatal messages should be reported through the // scripting layer rather on standard output. Fatal errors are always @@ -127,11 +127,11 @@ public: // stack of location so that the most recent is always the one that // will be assumed to be the current one. The pointer must remain // valid until the location is popped. - void PushLocation(const zeek::detail::Location* location) - { locations.push_back(std::pair(location, 0)); } + void PushLocation(const detail::Location* location) + { locations.push_back(std::pair(location, 0)); } - void PushLocation(const zeek::detail::Location* loc1, const zeek::detail::Location* loc2) - { locations.push_back(std::pair(loc1, loc2)); } + void PushLocation(const detail::Location* loc1, const detail::Location* loc2) + { locations.push_back(std::pair(loc1, loc2)); } // Removes the top-most location information from stack. void PopLocation() @@ -151,7 +151,7 @@ public: /** * Reset/cleanup state tracking for a "flow" weird. */ - void ResetFlowWeird(const zeek::IPAddr& orig, const zeek::IPAddr& resp); + void ResetFlowWeird(const IPAddr& orig, const IPAddr& resp); /** * Reset/cleanup state tracking for a "expired conn" weird. @@ -259,19 +259,19 @@ public: { after_zeek_init = true; } private: - void DoLog(const char* prefix, zeek::EventHandlerPtr event, FILE* out, + void DoLog(const char* prefix, EventHandlerPtr event, FILE* out, Connection* conn, ValPList* addl, bool location, bool time, const char* postfix, const char* fmt, va_list ap) __attribute__((format(printf, 10, 0))); // WeirdHelper doesn't really have to be variadic, but it calls DoLog // and that takes va_list anyway. - void WeirdHelper(zeek::EventHandlerPtr event, ValPList vl, const char* fmt_name, ...) __attribute__((format(printf, 4, 5)));; + void WeirdHelper(EventHandlerPtr event, ValPList vl, const char* fmt_name, ...) __attribute__((format(printf, 4, 5)));; void UpdateWeirdStats(const char* name); inline bool WeirdOnSamplingWhiteList(const char* name) { return weird_sampling_whitelist.find(name) != weird_sampling_whitelist.end(); } bool PermitNetWeird(const char* name); - bool PermitFlowWeird(const char* name, const zeek::IPAddr& o, const zeek::IPAddr& r); - bool PermitExpiredConnWeird(const char* name, const zeek::RecordVal& conn_id); + bool PermitFlowWeird(const char* name, const IPAddr& o, const IPAddr& r); + bool PermitExpiredConnWeird(const char* name, const RecordVal& conn_id); bool EmitToStderr(bool flag) { return flag || ! after_zeek_init; } @@ -285,7 +285,7 @@ private: bool after_zeek_init; bool abort_on_scripting_errors = false; - std::list > locations; + std::list > locations; uint64_t weird_count; WeirdCountMap weird_count_by_type; diff --git a/src/Rule.cc b/src/Rule.cc index b08849314f..17fe5236f9 100644 --- a/src/Rule.cc +++ b/src/Rule.cc @@ -75,7 +75,7 @@ void Rule::AddPattern(const char* str, Rule::PatternType type, uint32_t offset, uint32_t depth) { Pattern* p = new Pattern; - p->pattern = zeek::util::copy_string(str); + p->pattern = util::copy_string(str); p->type = type; p->id = ++pattern_counter; p->offset = offset; @@ -88,7 +88,7 @@ void Rule::AddPattern(const char* str, Rule::PatternType type, void Rule::AddRequires(const char* id, bool opposite_direction, bool negate) { Precond* p = new Precond; - p->id = zeek::util::copy_string(id); + p->id = util::copy_string(id); p->rule = nullptr; p->opposite_dir = opposite_direction; p->negate = negate; diff --git a/src/Rule.h b/src/Rule.h index 3a48f2c288..f982722422 100644 --- a/src/Rule.h +++ b/src/Rule.h @@ -17,14 +17,14 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Rule, zeek::detail); namespace zeek::detail { -using rule_list = zeek::PList; +using rule_list = PList; using rule_dict = std::map; class Rule { public: - Rule(const char* arg_id, const zeek::detail::Location& arg_location) + Rule(const char* arg_id, const Location& arg_location) { - id = zeek::util::copy_string(arg_id); + id = util::copy_string(arg_id); idx = rule_counter++; location = arg_location; active = true; @@ -50,7 +50,7 @@ public: uint32_t offset = 0, uint32_t depth = INT_MAX); void AddRequires(const char* id, bool opposite_direction, bool negate); - const zeek::detail::Location& GetLocation() const { return location; } + const Location& GetLocation() const { return location; } void PrintDebug(); @@ -61,9 +61,9 @@ private: void SortHdrTests(); - using rule_action_list = zeek::PList; - using rule_condition_list = zeek::PList; - using rule_hdr_test_list = zeek::PList; + using rule_action_list = PList; + using rule_condition_list = PList; + using rule_hdr_test_list = PList; rule_hdr_test_list hdr_tests; rule_condition_list conditions; @@ -77,7 +77,7 @@ private: bool negate; // negate test }; - using precond_list = zeek::PList; + using precond_list = PList; precond_list preconds; rule_list dependents; // rules w/ us as a precondition @@ -95,13 +95,13 @@ private: uint32_t depth; }; - using pattern_list = zeek::PList; + using pattern_list = PList; pattern_list patterns; Rule* next; // Linkage within RuleHdrTest tree: // Ptr to next rule using the same RuleHdrTests - zeek::detail::Location location; + Location location; // Rules and payloads are numbered individually. static unsigned int rule_counter; diff --git a/src/RuleAction.cc b/src/RuleAction.cc index b99a2697bd..4bca69bc6d 100644 --- a/src/RuleAction.cc +++ b/src/RuleAction.cc @@ -16,18 +16,18 @@ namespace zeek::detail { RuleActionEvent::RuleActionEvent(const char* arg_msg) { - msg = zeek::util::copy_string(arg_msg); + msg = util::copy_string(arg_msg); } void RuleActionEvent::DoAction(const Rule* parent, RuleEndpointState* state, const u_char* data, int len) { if ( signature_match ) - zeek::event_mgr.Enqueue( + event_mgr.Enqueue( signature_match, - zeek::IntrusivePtr{zeek::AdoptRef{}, rule_matcher->BuildRuleStateValue(parent, state)}, - zeek::make_intrusive(msg), - data ? zeek::make_intrusive(len, (const char*)data) : zeek::val_mgr->EmptyString() + IntrusivePtr{AdoptRef{}, rule_matcher->BuildRuleStateValue(parent, state)}, + make_intrusive(msg), + data ? make_intrusive(len, (const char*)data) : val_mgr->EmptyString() ); } @@ -38,7 +38,7 @@ void RuleActionEvent::PrintDebug() RuleActionMIME::RuleActionMIME(const char* arg_mime, int arg_strength) { - mime = zeek::util::copy_string(arg_mime); + mime = util::copy_string(arg_mime); strength = arg_strength; } @@ -52,31 +52,31 @@ RuleActionAnalyzer::RuleActionAnalyzer(const char* arg_analyzer) string str(arg_analyzer); string::size_type pos = str.find(':'); string arg = str.substr(0, pos); - analyzer = zeek::analyzer_mgr->GetComponentTag(arg.c_str()); + analyzer = analyzer_mgr->GetComponentTag(arg.c_str()); if ( ! analyzer ) - zeek::reporter->Warning("unknown analyzer '%s' specified in rule", arg.c_str()); + reporter->Warning("unknown analyzer '%s' specified in rule", arg.c_str()); if ( pos != string::npos ) { arg = str.substr(pos + 1); - child_analyzer = zeek::analyzer_mgr->GetComponentTag(arg.c_str()); + child_analyzer = analyzer_mgr->GetComponentTag(arg.c_str()); if ( ! child_analyzer ) - zeek::reporter->Warning("unknown analyzer '%s' specified in rule", arg.c_str()); + reporter->Warning("unknown analyzer '%s' specified in rule", arg.c_str()); } else - child_analyzer = zeek::analyzer::Tag(); + child_analyzer = analyzer::Tag(); } void RuleActionAnalyzer::PrintDebug() { if ( ! child_analyzer ) - fprintf(stderr, "|%s|\n", zeek::analyzer_mgr->GetComponentName(analyzer).c_str()); + fprintf(stderr, "|%s|\n", analyzer_mgr->GetComponentName(analyzer).c_str()); else fprintf(stderr, "|%s:%s|\n", - zeek::analyzer_mgr->GetComponentName(analyzer).c_str(), - zeek::analyzer_mgr->GetComponentName(child_analyzer).c_str()); + analyzer_mgr->GetComponentName(analyzer).c_str(), + analyzer_mgr->GetComponentName(child_analyzer).c_str()); } @@ -85,7 +85,7 @@ void RuleActionEnable::DoAction(const Rule* parent, RuleEndpointState* state, { if ( ! ChildAnalyzer() ) { - if ( ! zeek::analyzer_mgr->IsEnabled(Analyzer()) ) + if ( ! analyzer_mgr->IsEnabled(Analyzer()) ) return; if ( state->PIA() ) @@ -93,7 +93,7 @@ void RuleActionEnable::DoAction(const Rule* parent, RuleEndpointState* state, } else { - if ( ! zeek::analyzer_mgr->IsEnabled(ChildAnalyzer()) ) + if ( ! analyzer_mgr->IsEnabled(ChildAnalyzer()) ) return; // This is ugly and works only if there exists only one diff --git a/src/RuleAction.h b/src/RuleAction.h index f9ebfd8181..aedfc6eaed 100644 --- a/src/RuleAction.h +++ b/src/RuleAction.h @@ -71,12 +71,12 @@ public: void PrintDebug() override; - zeek::analyzer::Tag Analyzer() const { return analyzer; } - zeek::analyzer::Tag ChildAnalyzer() const { return child_analyzer; } + analyzer::Tag Analyzer() const { return analyzer; } + analyzer::Tag ChildAnalyzer() const { return child_analyzer; } private: - zeek::analyzer::Tag analyzer; - zeek::analyzer::Tag child_analyzer; + analyzer::Tag analyzer; + analyzer::Tag child_analyzer; }; class RuleActionEnable : public RuleActionAnalyzer { diff --git a/src/RuleCondition.cc b/src/RuleCondition.cc index 09ce04cc79..977eb9f8e2 100644 --- a/src/RuleCondition.cc +++ b/src/RuleCondition.cc @@ -25,12 +25,12 @@ namespace zeek::detail { bool RuleConditionTCPState::DoMatch(Rule* rule, RuleEndpointState* state, const u_char* data, int len) { - zeek::analyzer::Analyzer* root = state->GetAnalyzer()->Conn()->GetRootAnalyzer(); + analyzer::Analyzer* root = state->GetAnalyzer()->Conn()->GetRootAnalyzer(); if ( ! root || ! root->IsAnalyzer("TCP") ) return false; - auto* ta = static_cast(root); + auto* ta = static_cast(root); if ( tcpstates & STATE_STATELESS ) return true; @@ -122,7 +122,7 @@ bool RuleConditionPayloadSize::DoMatch(Rule* rule, RuleEndpointState* state, return payload_size >= val; default: - zeek::reporter->InternalError("unknown comparison type"); + reporter->InternalError("unknown comparison type"); } // Should not be reached @@ -131,25 +131,25 @@ bool RuleConditionPayloadSize::DoMatch(Rule* rule, RuleEndpointState* state, RuleConditionEval::RuleConditionEval(const char* func) { - id = zeek::detail::global_scope()->Find(func).get(); + id = global_scope()->Find(func).get(); if ( ! id ) { rules_error("unknown identifier", func); return; } - if ( id->GetType()->Tag() == zeek::TYPE_FUNC ) + if ( id->GetType()->Tag() == TYPE_FUNC ) { // Validate argument quantity and type. - zeek::FuncType* f = id->GetType()->AsFuncType(); + FuncType* f = id->GetType()->AsFuncType(); - if ( f->Yield()->Tag() != zeek::TYPE_BOOL ) + if ( f->Yield()->Tag() != TYPE_BOOL ) rules_error("eval function type must yield a 'bool'", func); - static auto signature_state = zeek::id::find_type("signature_state"); - zeek::TypeList tl; + static auto signature_state = id::find_type("signature_state"); + TypeList tl; tl.Append(signature_state); - tl.Append(zeek::base_type(zeek::TYPE_STRING)); + tl.Append(base_type(TYPE_STRING)); if ( ! f->CheckArgs(tl.GetTypes()) ) rules_error("eval function parameters must be a 'signature_state' " @@ -162,22 +162,22 @@ bool RuleConditionEval::DoMatch(Rule* rule, RuleEndpointState* state, { if ( ! id->HasVal() ) { - zeek::reporter->Error("undefined value"); + reporter->Error("undefined value"); return false; } - if ( id->GetType()->Tag() != zeek::TYPE_FUNC ) + if ( id->GetType()->Tag() != TYPE_FUNC ) return id->GetVal()->AsBool(); // Call function with a signature_state value as argument. - zeek::Args args; + Args args; args.reserve(2); - args.emplace_back(zeek::AdoptRef{}, rule_matcher->BuildRuleStateValue(rule, state)); + args.emplace_back(AdoptRef{}, rule_matcher->BuildRuleStateValue(rule, state)); if ( data ) - args.emplace_back(zeek::make_intrusive(len, (const char*) data)); + args.emplace_back(make_intrusive(len, (const char*) data)); else - args.emplace_back(zeek::val_mgr->EmptyString()); + args.emplace_back(val_mgr->EmptyString()); bool result = false; diff --git a/src/RuleCondition.h b/src/RuleCondition.h index 55601dd3bd..aa735cf854 100644 --- a/src/RuleCondition.h +++ b/src/RuleCondition.h @@ -114,7 +114,7 @@ public: void PrintDebug() override; private: - zeek::detail::ID* id; + ID* id; }; } // namespace zeek::detail diff --git a/src/RuleMatcher.cc b/src/RuleMatcher.cc index 5e1a6aeda2..194ee2b4d6 100644 --- a/src/RuleMatcher.cc +++ b/src/RuleMatcher.cc @@ -48,7 +48,7 @@ static bool is_member_of(const int_list& l, int_list::value_type v) } RuleHdrTest::RuleHdrTest(Prot arg_prot, uint32_t arg_offset, uint32_t arg_size, - Comp arg_comp, maskedvalue_list* arg_vals) + Comp arg_comp, maskedvalue_list* arg_vals) { prot = arg_prot; offset = arg_offset; @@ -64,7 +64,7 @@ RuleHdrTest::RuleHdrTest(Prot arg_prot, uint32_t arg_offset, uint32_t arg_size, level = 0; } -RuleHdrTest::RuleHdrTest(Prot arg_prot, Comp arg_comp, vector arg_v) +RuleHdrTest::RuleHdrTest(Prot arg_prot, Comp arg_comp, vector arg_v) { prot = arg_prot; offset = 0; @@ -81,15 +81,15 @@ RuleHdrTest::RuleHdrTest(Prot arg_prot, Comp arg_comp, vector ar level = 0; } -zeek::Val* RuleMatcher::BuildRuleStateValue(const Rule* rule, - const RuleEndpointState* state) const +Val* RuleMatcher::BuildRuleStateValue(const Rule* rule, + const RuleEndpointState* state) const { - static auto signature_state = zeek::id::find_type("signature_state"); - auto* val = new zeek::RecordVal(signature_state); - val->Assign(0, zeek::make_intrusive(rule->ID())); + static auto signature_state = id::find_type("signature_state"); + auto* val = new RecordVal(signature_state); + val->Assign(0, make_intrusive(rule->ID())); val->Assign(1, state->GetAnalyzer()->ConnVal()); - val->Assign(2, zeek::val_mgr->Bool(state->is_orig)); - val->Assign(3, zeek::val_mgr->Count(state->payload_size)); + val->Assign(2, val_mgr->Bool(state->is_orig)); + val->Assign(3, val_mgr->Count(state->payload_size)); return val; } @@ -114,7 +114,7 @@ RuleHdrTest::RuleHdrTest(RuleHdrTest& h) copied_set->re = nullptr; copied_set->ids = orig_set->ids; for ( const auto& pattern : orig_set->patterns ) - copied_set->patterns.push_back(zeek::util::copy_string(pattern)); + copied_set->patterns.push_back(util::copy_string(pattern)); delete copied_set; // TODO: Why do we create copied_set only to then // never use it? @@ -184,9 +184,9 @@ void RuleHdrTest::PrintDebug() fprintf(stderr, "\n"); } -RuleEndpointState::RuleEndpointState(zeek::analyzer::Analyzer* arg_analyzer, bool arg_is_orig, +RuleEndpointState::RuleEndpointState(analyzer::Analyzer* arg_analyzer, bool arg_is_orig, RuleEndpointState* arg_opposite, - zeek::analyzer::pia::PIA* arg_PIA) + analyzer::pia::PIA* arg_PIA) { payload_size = -1; analyzer = arg_analyzer; @@ -262,11 +262,11 @@ bool RuleMatcher::ReadFiles(const std::vector& files) for ( const auto& f : files ) { - rules_in = zeek::util::open_file(zeek::util::find_file(f, zeek::util::zeek_path(), ".sig")); + rules_in = util::open_file(util::find_file(f, util::zeek_path(), ".sig")); if ( ! rules_in ) { - zeek::reporter->Error("Can't open signature file %s", f.data()); + reporter->Error("Can't open signature file %s", f.data()); return false; } @@ -332,7 +332,7 @@ void RuleMatcher::BuildRulesTree() } void RuleMatcher::InsertRuleIntoTree(Rule* r, int testnr, - RuleHdrTest* dest, int level) + RuleHdrTest* dest, int level) { // Initiliaze the preconditions for ( const auto& pc : r->preconds ) @@ -384,7 +384,7 @@ void RuleMatcher::InsertRuleIntoTree(Rule* r, int testnr, } void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs, - int_list* ids) + int_list* ids) { // For each type, get all patterns on this node. for ( Rule* r = hdr_test->pattern_rules; r; r = r->next ) @@ -435,7 +435,7 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs, } void RuleMatcher::BuildPatternSets(RuleHdrTest::pattern_set_list* dst, - const string_list& exprs, const int_list& ids) + const string_list& exprs, const int_list& ids) { assert(static_cast(exprs.length()) == ids.size()); @@ -483,7 +483,7 @@ static inline uint32_t getval(const u_char* data, int size) return ntohl(*(uint32_t*) data); default: - zeek::reporter->InternalError("illegal HdrTest size"); + reporter->InternalError("illegal HdrTest size"); } // Should not be reached. @@ -506,12 +506,12 @@ static inline bool match_or(const maskedvalue_list& mvals, uint32_t v, FuncT com // Evaluate a prefix list (matches if at least one value matches). template -static inline bool match_or(const vector& prefixes, const zeek::IPAddr& a, +static inline bool match_or(const vector& prefixes, const IPAddr& a, FuncT comp) { for ( size_t i = 0; i < prefixes.size(); ++i ) { - zeek::IPAddr masked(a); + IPAddr masked(a); masked.Mask(prefixes[i].LengthIPv6()); if ( comp(masked, prefixes[i].Prefix()) ) return true; @@ -535,12 +535,12 @@ static inline bool match_not_and(const maskedvalue_list& mvals, uint32_t v, // Evaluate a prefix list (doesn't match if any value matches). template -static inline bool match_not_and(const vector& prefixes, - const zeek::IPAddr& a, FuncT comp) +static inline bool match_not_and(const vector& prefixes, + const IPAddr& a, FuncT comp) { for ( size_t i = 0; i < prefixes.size(); ++i ) { - zeek::IPAddr masked(a); + IPAddr masked(a); masked.Mask(prefixes[i].LengthIPv6()); if ( comp(masked, prefixes[i].Prefix()) ) return false; @@ -577,42 +577,42 @@ static inline bool compare(const maskedvalue_list& mvals, uint32_t v, break; default: - zeek::reporter->InternalError("unknown RuleHdrTest comparison type"); + reporter->InternalError("unknown RuleHdrTest comparison type"); break; } return false; } -static inline bool compare(const vector& prefixes, const zeek::IPAddr& a, +static inline bool compare(const vector& prefixes, const IPAddr& a, RuleHdrTest::Comp comp) { switch ( comp ) { case RuleHdrTest::EQ: - return match_or(prefixes, a, std::equal_to()); + return match_or(prefixes, a, std::equal_to()); break; case RuleHdrTest::NE: - return match_not_and(prefixes, a, std::equal_to()); + return match_not_and(prefixes, a, std::equal_to()); break; case RuleHdrTest::LT: - return match_or(prefixes, a, std::less()); + return match_or(prefixes, a, std::less()); break; case RuleHdrTest::GT: - return match_or(prefixes, a, std::greater()); + return match_or(prefixes, a, std::greater()); break; case RuleHdrTest::LE: - return match_or(prefixes, a, std::less_equal()); + return match_or(prefixes, a, std::less_equal()); break; case RuleHdrTest::GE: - return match_or(prefixes, a, std::greater_equal()); + return match_or(prefixes, a, std::greater_equal()); break; default: - zeek::reporter->InternalError("unknown RuleHdrTest comparison type"); + reporter->InternalError("unknown RuleHdrTest comparison type"); break; } return false; @@ -638,7 +638,7 @@ RuleFileMagicState* RuleMatcher::InitFileMagic() const bool RuleMatcher::AllRulePatternsMatched(const Rule* r, MatchPos matchpos, const AcceptingMatchSet& ams) { - DBG_LOG(zeek::DBG_RULES, "Checking rule: %s", r->id); + DBG_LOG(DBG_RULES, "Checking rule: %s", r->id); // Check whether all patterns of the rule have matched. for ( const auto& pattern : r->patterns ) @@ -653,7 +653,7 @@ bool RuleMatcher::AllRulePatternsMatched(const Rule* r, MatchPos matchpos, // FIXME: How to check for offset ??? ### } - DBG_LOG(zeek::DBG_RULES, "All patterns of rule satisfied"); + DBG_LOG(DBG_RULES, "All patterns of rule satisfied"); return true; } @@ -667,16 +667,16 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state, if ( ! state ) { - zeek::reporter->Warning("RuleFileMagicState not initialized yet."); + reporter->Warning("RuleFileMagicState not initialized yet."); return rval; } #ifdef DEBUG - if ( debug_logger.IsEnabled(zeek::DBG_RULES) ) + if ( debug_logger.IsEnabled(DBG_RULES) ) { - const char* s = zeek::util::fmt_bytes(reinterpret_cast(data), + const char* s = util::fmt_bytes(reinterpret_cast(data), min(40, static_cast(len))); - DBG_LOG(zeek::DBG_RULES, "Matching %s rules on |%s%s|", + DBG_LOG(DBG_RULES, "Matching %s rules on |%s%s|", Rule::TypeToString(Rule::FILE_MAGIC), s, len > 40 ? "..." : ""); } @@ -693,7 +693,7 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state, if ( ! newmatch ) return rval; - DBG_LOG(zeek::DBG_RULES, "New pattern match found"); + DBG_LOG(DBG_RULES, "New pattern match found"); AcceptingMatchSet accepted_matches; @@ -739,10 +739,10 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state, return rval; } -RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer, - const zeek::IP_Hdr* ip, int caplen, +RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer, + const IP_Hdr* ip, int caplen, RuleEndpointState* opposite, - bool from_orig, zeek::analyzer::pia::PIA* pia) + bool from_orig, analyzer::pia::PIA* pia) { RuleEndpointState* state = new RuleEndpointState(analyzer, from_orig, opposite, pia); @@ -754,7 +754,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer, { RuleHdrTest* hdr_test = tests[h]; - DBG_LOG(zeek::DBG_RULES, "HdrTest %d matches (%s%s)", hdr_test->id, + DBG_LOG(DBG_RULES, "HdrTest %d matches (%s%s)", hdr_test->id, hdr_test->pattern_rules ? "+" : "-", hdr_test->pure_rules ? "+" : "-"); @@ -779,8 +779,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer, { assert(set->re); - RuleEndpointState::Matcher* m = - new RuleEndpointState::Matcher; + auto* m = new RuleEndpointState::Matcher; m->state = new RE_Match_State(set->re); m->type = (Rule::PatternType) i; state->matchers.push_back(m); @@ -832,7 +831,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer, break; default: - zeek::reporter->InternalError("unknown RuleHdrTest protocol type"); + reporter->InternalError("unknown RuleHdrTest protocol type"); break; } @@ -852,12 +851,12 @@ RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer, } void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type, - const u_char* data, int data_len, - bool bol, bool eol, bool clear) + const u_char* data, int data_len, + bool bol, bool eol, bool clear) { if ( ! state ) { - zeek::reporter->Warning("RuleEndpointState not initialized yet."); + reporter->Warning("RuleEndpointState not initialized yet."); return; } @@ -869,12 +868,12 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type, bool newmatch = false; #ifdef DEBUG - if ( debug_logger.IsEnabled(zeek::DBG_RULES) ) + if ( debug_logger.IsEnabled(DBG_RULES) ) { const char* s = - zeek::util::fmt_bytes((const char *) data, min(40, data_len)); + util::fmt_bytes((const char *) data, min(40, data_len)); - DBG_LOG(zeek::DBG_RULES, "Matching %s rules [%d,%d] on |%s%s|", + DBG_LOG(DBG_RULES, "Matching %s rules [%d,%d] on |%s%s|", Rule::TypeToString(type), bol, eol, s, data_len > 40 ? "..." : ""); } @@ -905,7 +904,7 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type, if ( ! newmatch ) return; - DBG_LOG(zeek::DBG_RULES, "New pattern match found"); + DBG_LOG(DBG_RULES, "New pattern match found"); AcceptingMatchSet accepted_matches; @@ -941,17 +940,17 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type, { Rule* r = *it; - DBG_LOG(zeek::DBG_RULES, "Accepted rule: %s", r->id); + DBG_LOG(DBG_RULES, "Accepted rule: %s", r->id); for ( const auto& h : state->hdr_tests ) { - DBG_LOG(zeek::DBG_RULES, "Checking for accepted rule on HdrTest %d", h->id); + DBG_LOG(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(zeek::DBG_RULES, "On current node"); + DBG_LOG(DBG_RULES, "On current node"); // Skip if rule already fired for this connection. if ( is_member_of(state->matched_rules, r->Index()) ) @@ -961,11 +960,11 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type, if ( ! state->matched_by_patterns.is_member(r) ) { state->matched_by_patterns.push_back(r); - zeek::String* s = new zeek::String(data, data_len, false); + String* s = new String(data, data_len, false); state->matched_text.push_back(s); } - DBG_LOG(zeek::DBG_RULES, "And has not already fired"); + DBG_LOG(DBG_RULES, "And has not already fired"); // Eval additional conditions. if ( ! EvalRuleConditions(r, state, data, data_len, false) ) continue; @@ -1001,17 +1000,17 @@ void RuleMatcher::ExecPureRules(RuleEndpointState* state, bool eos) } } -bool RuleMatcher::ExecRulePurely(Rule* r, zeek::String* s, +bool RuleMatcher::ExecRulePurely(Rule* r, String* s, RuleEndpointState* state, bool eos) { if ( is_member_of(state->matched_rules, r->Index()) ) return false; - DBG_LOG(zeek::DBG_RULES, "Checking rule %s purely", r->ID()); + DBG_LOG(DBG_RULES, "Checking rule %s purely", r->ID()); if ( EvalRuleConditions(r, state, nullptr, 0, eos) ) { - DBG_LOG(zeek::DBG_RULES, "MATCH!"); + DBG_LOG(DBG_RULES, "MATCH!"); if ( s ) ExecRuleActions(r, state, s->Bytes(), s->Len(), eos); @@ -1027,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(zeek::DBG_RULES, "Evaluating conditions for rule %s", r->ID()); + DBG_LOG(DBG_RULES, "Evaluating conditions for rule %s", r->ID()); // Check for other rules which have to match first. for ( const auto& pc : r->preconds ) @@ -1064,7 +1063,7 @@ bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state, if ( ! cond->DoMatch(r, state, data, len) ) return false; - DBG_LOG(zeek::DBG_RULES, "Conditions met: MATCH! %s", r->ID()); + DBG_LOG(DBG_RULES, "Conditions met: MATCH! %s", r->ID()); return true; } @@ -1230,22 +1229,22 @@ void RuleMatcher::GetStats(Stats* stats, RuleHdrTest* hdr_test) GetStats(stats, h); } -void RuleMatcher::DumpStats(zeek::File* f) +void RuleMatcher::DumpStats(File* f) { Stats stats; GetStats(&stats); - f->Write(zeek::util::fmt("%.6f computed dfa states = %d; classes = ??; " + f->Write(util::fmt("%.6f computed dfa states = %d; classes = ??; " "computed trans. = %d; matchers = %d; mem = %d\n", - zeek::run_state::network_time, stats.dfa_states, stats.computed, + run_state::network_time, stats.dfa_states, stats.computed, stats.matchers, stats.mem)); - f->Write(zeek::util::fmt("%.6f DFA cache hits = %d; misses = %d\n", zeek::run_state::network_time, + f->Write(util::fmt("%.6f DFA cache hits = %d; misses = %d\n", run_state::network_time, stats.hits, stats.misses)); DumpStateStats(f, root); } -void RuleMatcher::DumpStateStats(zeek::File* f, RuleHdrTest* hdr_test) +void RuleMatcher::DumpStateStats(File* f, RuleHdrTest* hdr_test) { if ( ! hdr_test ) return; @@ -1257,15 +1256,15 @@ void RuleMatcher::DumpStateStats(zeek::File* f, RuleHdrTest* hdr_test) RuleHdrTest::PatternSet* set = hdr_test->psets[i][j]; assert(set->re); - f->Write(zeek::util::fmt("%.6f %d DFA states in %s group %d from sigs ", - zeek::run_state::network_time, - set->re->DFA()->NumStates(), - Rule::TypeToString((Rule::PatternType)i), j)); + f->Write(util::fmt("%.6f %d DFA states in %s group %d from sigs ", + run_state::network_time, + set->re->DFA()->NumStates(), + Rule::TypeToString((Rule::PatternType)i), j)); for ( const auto& id : set->ids ) { Rule* r = Rule::rule_table[id - 1]; - f->Write(zeek::util::fmt("%s ", r->ID())); + f->Write(util::fmt("%s ", r->ID())); } f->Write("\n"); @@ -1276,9 +1275,9 @@ void RuleMatcher::DumpStateStats(zeek::File* f, RuleHdrTest* hdr_test) DumpStateStats(f, h); } -static zeek::Val* get_bro_val(const char* label) +static Val* get_bro_val(const char* label) { - auto id = zeek::detail::lookup_ID(label, GLOBAL_MODULE_NAME, false); + auto id = lookup_ID(label, GLOBAL_MODULE_NAME, false); if ( ! id ) { rules_error("unknown script-level identifier", label); @@ -1292,26 +1291,26 @@ static zeek::Val* get_bro_val(const char* label) // Converts an atomic Val and appends it to the list. For subnet types, // if the prefix_vector param isn't null, appending to that is preferred // over appending to the masked val list. -static bool val_to_maskedval(zeek::Val* v, maskedvalue_list* append_to, - vector* prefix_vector) +static bool val_to_maskedval(Val* v, maskedvalue_list* append_to, + vector* prefix_vector) { MaskedValue* mval = new MaskedValue; switch ( v->GetType()->Tag() ) { - case zeek::TYPE_PORT: + case TYPE_PORT: mval->val = v->AsPortVal()->Port(); mval->mask = 0xffffffff; break; - case zeek::TYPE_BOOL: - case zeek::TYPE_COUNT: - case zeek::TYPE_ENUM: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_COUNT: + case TYPE_ENUM: + case TYPE_INT: mval->val = v->CoerceToUnsigned(); mval->mask = 0xffffffff; break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { if ( prefix_vector ) { @@ -1360,13 +1359,13 @@ static bool val_to_maskedval(zeek::Val* v, maskedvalue_list* append_to, } void id_to_maskedvallist(const char* id, maskedvalue_list* append_to, - vector* prefix_vector) + vector* prefix_vector) { - zeek::Val* v = get_bro_val(id); + Val* v = get_bro_val(id); if ( ! v ) return; - if ( v->GetType()->Tag() == zeek::TYPE_TABLE ) + if ( v->GetType()->Tag() == TYPE_TABLE ) { auto lv = v->AsTableVal()->ToPureListVal(); @@ -1381,14 +1380,14 @@ void id_to_maskedvallist(const char* id, maskedvalue_list* append_to, char* id_to_str(const char* id) { - const zeek::String* src; + const String* src; char* dst; - zeek::Val* v = get_bro_val(id); + Val* v = get_bro_val(id); if ( ! v ) goto error; - if ( v->GetType()->Tag() != zeek::TYPE_STRING ) + if ( v->GetType()->Tag() != TYPE_STRING ) { rules_error("Identifier must refer to string"); goto error; @@ -1401,28 +1400,28 @@ char* id_to_str(const char* id) return dst; error: - char* dummy = zeek::util::copy_string(""); + char* dummy = util::copy_string(""); return dummy; } uint32_t id_to_uint(const char* id) { - zeek::Val* v = get_bro_val(id); + Val* v = get_bro_val(id); if ( ! v ) return 0; - zeek::TypeTag t = v->GetType()->Tag(); + TypeTag t = v->GetType()->Tag(); - if ( t == zeek::TYPE_BOOL || t == zeek::TYPE_COUNT || t == zeek::TYPE_ENUM || - t == zeek::TYPE_INT || t == zeek::TYPE_PORT ) + if ( t == TYPE_BOOL || t == TYPE_COUNT || t == TYPE_ENUM || + t == TYPE_INT || t == TYPE_PORT ) return v->CoerceToUnsigned(); rules_error("Identifier must refer to integer"); return 0; } -void RuleMatcherState::InitEndpointMatcher(zeek::analyzer::Analyzer* analyzer, const zeek::IP_Hdr* ip, - int caplen, bool from_orig, zeek::analyzer::pia::PIA* pia) +void RuleMatcherState::InitEndpointMatcher(analyzer::Analyzer* analyzer, const IP_Hdr* ip, + int caplen, bool from_orig, analyzer::pia::PIA* pia) { if ( ! rule_matcher ) return; @@ -1471,9 +1470,9 @@ void RuleMatcherState::FinishEndpointMatcher() orig_match_state = resp_match_state = nullptr; } -void RuleMatcherState::Match(Rule::PatternType type, const u_char* data, - int data_len, bool from_orig, - bool bol, bool eol, bool clear) + void RuleMatcherState::Match(Rule::PatternType type, const u_char* data, + int data_len, bool from_orig, + bool bol, bool eol, bool clear) { if ( ! rule_matcher ) return; diff --git a/src/RuleMatcher.h b/src/RuleMatcher.h index 9413e7d57c..d606492e88 100644 --- a/src/RuleMatcher.h +++ b/src/RuleMatcher.h @@ -57,13 +57,13 @@ struct MaskedValue { uint32_t mask; }; -using maskedvalue_list = zeek::PList; -using string_list = zeek::PList; -using bstr_list = zeek::PList; +using maskedvalue_list = PList; +using string_list = PList; +using bstr_list = PList; // Get values from Bro's script-level variables. extern void id_to_maskedvallist(const char* id, maskedvalue_list* append_to, - std::vector* prefix_vector = nullptr); + std::vector* prefix_vector = nullptr); extern char* id_to_str(const char* id); extern uint32_t id_to_uint(const char* id); @@ -75,7 +75,7 @@ public: RuleHdrTest(Prot arg_prot, uint32_t arg_offset, uint32_t arg_size, Comp arg_comp, maskedvalue_list* arg_vals); - RuleHdrTest(Prot arg_prot, Comp arg_comp, std::vector arg_v); + RuleHdrTest(Prot arg_prot, Comp arg_comp, std::vector arg_v); ~RuleHdrTest(); void PrintDebug(); @@ -92,7 +92,7 @@ private: Prot prot; Comp comp; maskedvalue_list* vals; - std::vector prefix_vals; // for use with IPSrc/IPDst comparisons + std::vector prefix_vals; // for use with IPSrc/IPDst comparisons uint32_t offset; uint32_t size; @@ -117,7 +117,7 @@ private: int_list ids; // (only needed for debugging) }; - using pattern_set_list = zeek::PList; + using pattern_set_list = PList; pattern_set_list psets[Rule::TYPES]; // List of rules belonging to this node. @@ -131,7 +131,7 @@ private: RuleHdrTest* child; }; -using rule_hdr_test_list = zeek::PList; +using rule_hdr_test_list = PList; // RuleEndpointState keeps the per-stream matching state of one // connection endpoint. @@ -139,7 +139,7 @@ class RuleEndpointState { public: ~RuleEndpointState(); - zeek::analyzer::Analyzer* GetAnalyzer() const { return analyzer; } + analyzer::Analyzer* GetAnalyzer() const { return analyzer; } bool IsOrig() { return is_orig; } // For flipping roles. @@ -151,26 +151,26 @@ public: // Returns -1 if no chunk has been fed yet at all. int PayloadSize() { return payload_size; } - zeek::analyzer::pia::PIA* PIA() const { return pia; } + analyzer::pia::PIA* PIA() const { return pia; } private: friend class RuleMatcher; // Constructor is private; use RuleMatcher::InitEndpoint() // for creating an instance. - RuleEndpointState(zeek::analyzer::Analyzer* arg_analyzer, bool arg_is_orig, - RuleEndpointState* arg_opposite, zeek::analyzer::pia::PIA* arg_PIA); + RuleEndpointState(analyzer::Analyzer* arg_analyzer, bool arg_is_orig, + RuleEndpointState* arg_opposite, analyzer::pia::PIA* arg_PIA); struct Matcher { RE_Match_State* state; Rule::PatternType type; }; - using matcher_list = zeek::PList; + using matcher_list = PList; - zeek::analyzer::Analyzer* analyzer; + analyzer::Analyzer* analyzer; RuleEndpointState* opposite; - zeek::analyzer::pia::PIA* pia; + analyzer::pia::PIA* pia; matcher_list matchers; rule_hdr_test_list hdr_tests; @@ -205,7 +205,7 @@ private: RE_Match_State* state; }; - using matcher_list = zeek::PList; + using matcher_list = PList; matcher_list matchers; }; @@ -262,9 +262,9 @@ public: // the given packet (which should be the first packet encountered for // this endpoint). If the matching is triggered by an PIA, a pointer to // it needs to be given. - RuleEndpointState* InitEndpoint(zeek::analyzer::Analyzer* analyzer, const zeek::IP_Hdr* ip, + RuleEndpointState* InitEndpoint(analyzer::Analyzer* analyzer, const IP_Hdr* ip, int caplen, RuleEndpointState* opposite, bool is_orig, - zeek::analyzer::pia::PIA* pia); + analyzer::pia::PIA* pia); // Finish matching for this stream. void FinishEndpoint(RuleEndpointState* state); @@ -304,11 +304,11 @@ public: unsigned int misses; // # cache misses }; - zeek::Val* BuildRuleStateValue(const Rule* rule, + Val* BuildRuleStateValue(const Rule* rule, const RuleEndpointState* state) const; void GetStats(Stats* stats, RuleHdrTest* hdr_test = nullptr); - void DumpStats(zeek::File* f); + void DumpStats(File* f); private: // Delete node and all children. @@ -338,7 +338,7 @@ private: // Eval a rule under the assumption that all its patterns // have already matched. s holds the text the rule matched, // or nil if N/A. - bool ExecRulePurely(Rule* r, zeek::String* s, + bool ExecRulePurely(Rule* r, String* s, RuleEndpointState* state, bool eos); // Execute the actions associated with a rule. @@ -351,7 +351,7 @@ private: void PrintTreeDebug(RuleHdrTest* node); - void DumpStateStats(zeek::File* f, RuleHdrTest* hdr_test); + void DumpStateStats(File* f, RuleHdrTest* hdr_test); static bool AllRulePatternsMatched(const Rule* r, MatchPos matchpos, const AcceptingMatchSet& ams); @@ -372,8 +372,8 @@ public: { delete orig_match_state; delete resp_match_state; } // ip may be nil. - void InitEndpointMatcher(zeek::analyzer::Analyzer* analyzer, const zeek::IP_Hdr* ip, - int caplen, bool from_orig, zeek::analyzer::pia::PIA* pia = nullptr); + void InitEndpointMatcher(analyzer::Analyzer* analyzer, const IP_Hdr* ip, + int caplen, bool from_orig, analyzer::pia::PIA* pia = nullptr); // bol/eol should be set to false for type Rule::PAYLOAD; they're // deduced automatically. diff --git a/src/RunState.cc b/src/RunState.cc index 92f01c80ef..3b960c1e14 100644 --- a/src/RunState.cc +++ b/src/RunState.cc @@ -47,9 +47,9 @@ extern int signal_val; namespace zeek::run_state { namespace detail { -zeek::iosource::PktDumper* pkt_dumper = nullptr; -zeek::iosource::PktSrc* current_pktsrc = nullptr; -zeek::iosource::IOSource* current_iosrc = nullptr; +iosource::PktDumper* pkt_dumper = nullptr; +iosource::PktSrc* current_pktsrc = nullptr; +iosource::IOSource* current_iosrc = nullptr; bool have_pending_timers = false; RETSIGTYPE watchdog(int /* signo */) @@ -79,7 +79,7 @@ RETSIGTYPE watchdog(int /* signo */) // handler and the allocation routines are not // reentrant. - double ct = zeek::util::current_time(); + double ct = util::current_time(); int int_ct = int(ct); int frac_ct = int((ct - int_ct) * 1e6); @@ -96,10 +96,10 @@ RETSIGTYPE watchdog(int /* signo */) // saving the packet which caused the // watchdog to trigger may be helpful, // so we'll save that one nevertheless. - pkt_dumper = zeek::iosource_mgr->OpenPktDumper("watchdog-pkt.pcap", false); + pkt_dumper = iosource_mgr->OpenPktDumper("watchdog-pkt.pcap", false); if ( ! pkt_dumper || pkt_dumper->IsError() ) { - zeek::reporter->Error("watchdog: can't open watchdog-pkt.pcap for writing"); + reporter->Error("watchdog: can't open watchdog-pkt.pcap for writing"); pkt_dumper = nullptr; } } @@ -112,7 +112,7 @@ RETSIGTYPE watchdog(int /* signo */) get_final_stats(); finish_run(0); - zeek::reporter->FatalErrorWithCore( + reporter->FatalErrorWithCore( "**watchdog timer expired, t = %d.%06d, start = %d.%06d, dispatched = %d", int_ct, frac_ct, int_pst, frac_pst, current_dispatched); @@ -141,23 +141,23 @@ void init_run(const std::optional& interface, reading_live = pseudo_realtime > 0.0; reading_traces = true; - zeek::iosource::PktSrc* ps = zeek::iosource_mgr->OpenPktSrc(*pcap_input_file, false); + iosource::PktSrc* ps = iosource_mgr->OpenPktSrc(*pcap_input_file, false); assert(ps); if ( ! ps->IsOpen() ) - zeek::reporter->FatalError("problem with trace file %s (%s)", - pcap_input_file->c_str(), ps->ErrorMsg()); + reporter->FatalError("problem with trace file %s (%s)", + pcap_input_file->c_str(), ps->ErrorMsg()); } else if ( interface ) { reading_live = true; reading_traces = false; - zeek::iosource::PktSrc* ps = zeek::iosource_mgr->OpenPktSrc(*interface, true); + iosource::PktSrc* ps = iosource_mgr->OpenPktSrc(*interface, true); assert(ps); if ( ! ps->IsOpen() ) - zeek::reporter->FatalError("problem with interface %s (%s)", + reporter->FatalError("problem with interface %s (%s)", interface->c_str(), ps->ErrorMsg()); } @@ -171,22 +171,22 @@ void init_run(const std::optional& interface, if ( pcap_output_file ) { const char* writefile = pcap_output_file->data(); - pkt_dumper = zeek::iosource_mgr->OpenPktDumper(writefile, false); + pkt_dumper = iosource_mgr->OpenPktDumper(writefile, false); assert(pkt_dumper); if ( ! pkt_dumper->IsOpen() ) - zeek::reporter->FatalError("problem opening dump file %s (%s)", + reporter->FatalError("problem opening dump file %s (%s)", writefile, pkt_dumper->ErrorMsg()); if ( const auto& id = zeek::detail::global_scope()->Find("trace_output_file") ) - id->SetVal(zeek::make_intrusive(writefile)); + id->SetVal(make_intrusive(writefile)); else - zeek::reporter->Error("trace_output_file not defined in bro.init"); + reporter->Error("trace_output_file not defined in bro.init"); } zeek::detail::init_ip_addr_anonymizers(); - zeek::sessions = new zeek::NetSessions(); + sessions = new NetSessions(); if ( do_watchdog ) { @@ -196,7 +196,7 @@ void init_run(const std::optional& interface, } } -void expire_timers(zeek::iosource::PktSrc* src_ps) +void expire_timers(iosource::PktSrc* src_ps) { zeek::detail::SegmentProfiler prof(zeek::detail::segment_logger, "expiring-timers"); @@ -205,14 +205,14 @@ void expire_timers(zeek::iosource::PktSrc* src_ps) zeek::detail::max_timer_expires - current_dispatched); } -void dispatch_packet(double t, const zeek::Packet* pkt, zeek::iosource::PktSrc* src_ps) +void dispatch_packet(double t, const Packet* pkt, iosource::PktSrc* src_ps) { if ( ! zeek_start_network_time ) { zeek_start_network_time = t; if ( network_time_init ) - zeek::event_mgr.Enqueue(network_time_init, zeek::Args{}); + event_mgr.Enqueue(network_time_init, Args{}); } // network_time never goes back. @@ -233,19 +233,19 @@ void dispatch_packet(double t, const zeek::Packet* pkt, zeek::iosource::PktSrc* if ( load_freq == 0 ) load_freq = uint32_t(0xffffffff) / uint32_t(zeek::detail::load_sample_freq); - if ( uint32_t(zeek::util::detail::random_number() & 0xffffffff) < load_freq ) + if ( uint32_t(util::detail::random_number() & 0xffffffff) < load_freq ) { // Drain the queued timer events so they're not // charged against this sample. - zeek::event_mgr.Drain(); + event_mgr.Drain(); zeek::detail::sample_logger = new zeek::detail::SampleLogger(); sp = new zeek::detail::SegmentProfiler(zeek::detail::sample_logger, "load-samp"); } } - zeek::sessions->NextPacket(t, pkt); - zeek::event_mgr.Drain(); + sessions->NextPacket(t, pkt); + event_mgr.Drain(); if ( sp ) { @@ -262,15 +262,15 @@ void dispatch_packet(double t, const zeek::Packet* pkt, zeek::iosource::PktSrc* void run_loop() { - zeek::util::detail::set_processing_status("RUNNING", "run_loop"); + util::detail::set_processing_status("RUNNING", "run_loop"); - std::vector ready; - ready.reserve(zeek::iosource_mgr->TotalSize()); + std::vector ready; + ready.reserve(iosource_mgr->TotalSize()); - while ( zeek::iosource_mgr->Size() || - (zeek::BifConst::exit_only_after_terminate && ! terminating) ) + while ( iosource_mgr->Size() || + (BifConst::exit_only_after_terminate && ! terminating) ) { - zeek::iosource_mgr->FindReadySources(&ready); + iosource_mgr->FindReadySources(&ready); #ifdef DEBUG static int loop_counter = 0; @@ -279,38 +279,38 @@ void run_loop() // starting with the first. if ( ! ready.empty() || loop_counter++ % 100 == 0 ) { - DBG_LOG(zeek::DBG_MAINLOOP, "realtime=%.6f ready_count=%zu", - zeek::util::current_time(), ready.size()); + DBG_LOG(DBG_MAINLOOP, "realtime=%.6f ready_count=%zu", + util::current_time(), ready.size()); if ( ! ready.empty() ) loop_counter = 0; } #endif current_iosrc = nullptr; - auto communication_enabled = zeek::broker_mgr->Active(); + auto communication_enabled = broker_mgr->Active(); if ( ! ready.empty() ) { for ( auto src : ready ) { - DBG_LOG(zeek::DBG_MAINLOOP, "processing source %s", src->Tag()); + DBG_LOG(DBG_MAINLOOP, "processing source %s", src->Tag()); current_iosrc = src; src->Process(); } } else if ( (have_pending_timers || communication_enabled || - zeek::BifConst::exit_only_after_terminate) && + BifConst::exit_only_after_terminate) && ! pseudo_realtime ) { // Take advantage of the lull to get up to // date on timers and events. Because we only // have timers as sources, going to sleep here // doesn't risk blocking on other inputs. - update_network_time(zeek::util::current_time()); + update_network_time(util::current_time()); expire_timers(); } - zeek::event_mgr.Drain(); + event_mgr.Drain(); processing_start_time = 0.0; // = "we're not processing now" current_dispatched = 0; @@ -331,7 +331,7 @@ void run_loop() { auto have_active_packet_source = false; - zeek::iosource::PktSrc* ps = zeek::iosource_mgr->GetPktSrc(); + iosource::PktSrc* ps = iosource_mgr->GetPktSrc(); if ( ps && ps->IsOpen() ) have_active_packet_source = true; @@ -350,30 +350,30 @@ void run_loop() void get_final_stats() { - zeek::iosource::PktSrc* ps = zeek::iosource_mgr->GetPktSrc(); + iosource::PktSrc* ps = iosource_mgr->GetPktSrc(); if ( ps && ps->IsLive() ) { - zeek::iosource::PktSrc::Stats s; + iosource::PktSrc::Stats s; ps->Statistics(&s); double dropped_pct = s.dropped > 0.0 ? ((double)s.dropped / ((double)s.received + (double)s.dropped)) * 100.0 : 0.0; - zeek::reporter->Info("%" PRIu64 " packets received on interface %s, %" PRIu64 " (%.2f%%) dropped", + reporter->Info("%" PRIu64 " packets received on interface %s, %" PRIu64 " (%.2f%%) dropped", s.received, ps->Path().c_str(), s.dropped, dropped_pct); } } void finish_run(int drain_events) { - zeek::util::detail::set_processing_status("TERMINATING", "finish_run"); + util::detail::set_processing_status("TERMINATING", "finish_run"); if ( drain_events ) { - if ( zeek::sessions ) - zeek::sessions->Drain(); + if ( sessions ) + sessions->Drain(); - zeek::event_mgr.Drain(); + event_mgr.Drain(); - if ( zeek::sessions ) - zeek::sessions->Done(); + if ( sessions ) + sessions->Done(); } #ifdef DEBUG @@ -388,9 +388,9 @@ void finish_run(int drain_events) void delete_run() { - zeek::util::detail::set_processing_status("TERMINATING", "delete_run"); + util::detail::set_processing_status("TERMINATING", "delete_run"); - delete zeek::sessions; + delete sessions; for ( int i = 0; i < zeek::detail::NUM_ADDR_ANONYMIZATION_METHODS; ++i ) delete zeek::detail::ip_anonymizer[i]; @@ -409,7 +409,7 @@ double zeek_start_network_time; // timestamp of first packet bool terminating = false; // whether we're done reading and finishing up bool is_parsing = false; -const zeek::Packet *current_pkt = nullptr; +const Packet *current_pkt = nullptr; int current_dispatched = 0; double current_timestamp = 0.0; @@ -418,7 +418,7 @@ static int _processing_suspended = 0; void suspend_processing() { if ( _processing_suspended == 0 ) - zeek::reporter->Info("processing suspended"); + reporter->Info("processing suspended"); ++_processing_suspended; } @@ -427,8 +427,8 @@ void continue_processing() { if ( _processing_suspended == 1 ) { - zeek::reporter->Info("processing continued"); - if ( zeek::iosource::PktSrc* ps = zeek::iosource_mgr->GetPktSrc() ) + reporter->Info("processing continued"); + if ( iosource::PktSrc* ps = iosource_mgr->GetPktSrc() ) ps->ContinueAfterSuspend(); } diff --git a/src/Scope.cc b/src/Scope.cc index 214cadddbe..ab2c7583d6 100644 --- a/src/Scope.cc +++ b/src/Scope.cc @@ -12,13 +12,13 @@ namespace zeek::detail { -using scope_list = zeek::PList; +using scope_list = PList; static scope_list scopes; static Scope* top_scope; -Scope::Scope(zeek::detail::IDPtr id, - std::unique_ptr> al) +Scope::Scope(IDPtr id, + std::unique_ptr> al) : scope_id(std::move(id)), attrs(std::move(al)) { return_type = nullptr; @@ -27,27 +27,27 @@ Scope::Scope(zeek::detail::IDPtr id, { const auto& id_type = scope_id->GetType(); - if ( id_type->Tag() == zeek::TYPE_ERROR ) + if ( id_type->Tag() == TYPE_ERROR ) return; - else if ( id_type->Tag() != zeek::TYPE_FUNC ) - zeek::reporter->InternalError("bad scope id"); + else if ( id_type->Tag() != TYPE_FUNC ) + reporter->InternalError("bad scope id"); - zeek::FuncType* ft = id->GetType()->AsFuncType(); + FuncType* ft = id->GetType()->AsFuncType(); return_type = ft->Yield(); } } -const zeek::detail::IDPtr& Scope::Find(std::string_view name) const +const IDPtr& Scope::Find(std::string_view name) const { auto entry = local.find(name); if ( entry != local.end() ) return entry->second; - return zeek::detail::ID::nil; + return ID::nil; } -zeek::detail::IDPtr Scope::Remove(std::string_view name) +IDPtr Scope::Remove(std::string_view name) { auto entry = local.find(name); @@ -61,12 +61,12 @@ zeek::detail::IDPtr Scope::Remove(std::string_view name) return nullptr; } -zeek::detail::IDPtr Scope::GenerateTemporary(const char* name) +IDPtr Scope::GenerateTemporary(const char* name) { - return zeek::make_intrusive(name, zeek::detail::SCOPE_FUNCTION, false); + return make_intrusive(name, SCOPE_FUNCTION, false); } -std::vector Scope::GetInits() +std::vector Scope::GetInits() { auto rval = std::move(inits); inits = {}; @@ -102,7 +102,7 @@ void Scope::Describe(ODesc* d) const for ( const auto& entry : local ) { - zeek::detail::ID* id = entry.second.get(); + ID* id = entry.second.get(); id->Describe(d); d->NL(); } @@ -112,7 +112,7 @@ TraversalCode Scope::Traverse(TraversalCallback* cb) const { for ( const auto& entry : local ) { - zeek::detail::ID* id = entry.second.get(); + ID* id = entry.second.get(); TraversalCode tc = id->Traverse(cb); HANDLE_TC_STMT_PRE(tc); } @@ -121,9 +121,9 @@ TraversalCode Scope::Traverse(TraversalCallback* cb) const } -const zeek::detail::IDPtr& lookup_ID(const char* name, const char* curr_module, - bool no_global, bool same_module_only, - bool check_export) +const IDPtr& lookup_ID(const char* name, const char* curr_module, + bool no_global, bool same_module_only, + bool check_export) { std::string fullname = make_full_var_name(curr_module, name); @@ -138,8 +138,8 @@ const zeek::detail::IDPtr& lookup_ID(const char* name, const char* curr_module, if ( id ) { if ( need_export && ! id->IsExport() && ! in_debug ) - zeek::reporter->Error("identifier is not exported: %s", - fullname.c_str()); + reporter->Error("identifier is not exported: %s", + fullname.c_str()); return id; } @@ -152,30 +152,30 @@ const zeek::detail::IDPtr& lookup_ID(const char* name, const char* curr_module, return global_scope()->Find(globalname); } - return zeek::detail::ID::nil; + return ID::nil; } -zeek::detail::IDPtr install_ID(const char* name, const char* module_name, - bool is_global, bool is_export) +IDPtr install_ID(const char* name, const char* module_name, + bool is_global, bool is_export) { if ( scopes.empty() && ! is_global ) - zeek::reporter->InternalError("local identifier in global scope"); + reporter->InternalError("local identifier in global scope"); - zeek::detail::IDScope scope; + IDScope scope; if ( is_export || ! module_name || (is_global && normalized_module_name(module_name) == GLOBAL_MODULE_NAME) ) - scope = zeek::detail::SCOPE_GLOBAL; + scope = SCOPE_GLOBAL; else if ( is_global ) - scope = zeek::detail::SCOPE_MODULE; + scope = SCOPE_MODULE; else - scope = zeek::detail::SCOPE_FUNCTION; + scope = SCOPE_FUNCTION; std::string full_name = make_full_var_name(module_name, name); - auto id = zeek::make_intrusive(full_name.data(), scope, is_export); + auto id = make_intrusive(full_name.data(), scope, is_export); - if ( zeek::detail::SCOPE_FUNCTION != scope ) + if ( SCOPE_FUNCTION != scope ) global_scope()->Insert(std::move(full_name), id); else { @@ -191,8 +191,8 @@ void push_existing_scope(Scope* scope) scopes.push_back(scope); } -void push_scope(zeek::detail::IDPtr id, - std::unique_ptr> attrs) +void push_scope(IDPtr id, + std::unique_ptr> attrs) { top_scope = new Scope(std::move(id), std::move(attrs)); scopes.push_back(top_scope); @@ -201,14 +201,14 @@ void push_scope(zeek::detail::IDPtr id, ScopePtr pop_scope() { if ( scopes.empty() ) - zeek::reporter->InternalError("scope underflow"); + reporter->InternalError("scope underflow"); scopes.pop_back(); Scope* old_top = top_scope; top_scope = scopes.empty() ? nullptr : scopes.back(); - return {zeek::AdoptRef{}, old_top}; + return {AdoptRef{}, old_top}; } Scope* current_scope() @@ -221,7 +221,7 @@ Scope* global_scope() return scopes.empty() ? 0 : scopes.front(); } -} +} // namespace zeek::detail zeek::detail::ID* lookup_ID( const char* name, const char* module, diff --git a/src/Scope.h b/src/Scope.h index 445d3ddc1a..b0ef2a7d78 100644 --- a/src/Scope.h +++ b/src/Scope.h @@ -21,59 +21,59 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Attr, zeek::detail); namespace zeek { template class IntrusivePtr; -using TypePtr = zeek::IntrusivePtr; +using TypePtr = IntrusivePtr; namespace detail { -using AttrPtr = zeek::IntrusivePtr; -using IDPtr = zeek::IntrusivePtr; +using AttrPtr = IntrusivePtr; +using IDPtr = IntrusivePtr; class Scope; -using ScopePtr = zeek::IntrusivePtr; +using ScopePtr = IntrusivePtr; class Scope : public Obj { public: - explicit Scope(zeek::detail::IDPtr id, - std::unique_ptr> al); + explicit Scope(IDPtr id, + std::unique_ptr> al); - const zeek::detail::IDPtr& Find(std::string_view name) const; + const IDPtr& Find(std::string_view name) const; template [[deprecated("Remove in v4.1. Use Find().")]] - zeek::detail::ID* Lookup(N&& name) const + ID* Lookup(N&& name) const { return Find(name).get(); } template void Insert(N&& name, I&& id) { local[std::forward(name)] = std::forward(id); } - zeek::detail::IDPtr Remove(std::string_view name); + IDPtr Remove(std::string_view name); [[deprecated("Remove in v4.1. Use GetID().")]] - zeek::detail::ID* ScopeID() const { return scope_id.get(); } + ID* ScopeID() const { return scope_id.get(); } - const zeek::detail::IDPtr& GetID() const + const IDPtr& GetID() const { return scope_id; } - const std::unique_ptr>& Attrs() const + const std::unique_ptr>& Attrs() const { return attrs; } [[deprecated("Remove in v4.1. Use GetReturnTrype().")]] - zeek::Type* ReturnType() const { return return_type.get(); } + Type* ReturnType() const { return return_type.get(); } - const zeek::TypePtr& GetReturnType() const + const TypePtr& GetReturnType() const { return return_type; } size_t Length() const { return local.size(); } const auto& Vars() { return local; } - zeek::detail::IDPtr GenerateTemporary(const char* name); + IDPtr GenerateTemporary(const char* name); // Returns the list of variables needing initialization, and // removes it from this Scope. - std::vector GetInits(); + std::vector GetInits(); // Adds a variable to the list. - void AddInit(zeek::detail::IDPtr id) + void AddInit(IDPtr id) { inits.emplace_back(std::move(id)); } void Describe(ODesc* d) const override; @@ -81,26 +81,25 @@ public: TraversalCode Traverse(TraversalCallback* cb) const; protected: - zeek::detail::IDPtr scope_id; - std::unique_ptr> attrs; - zeek::TypePtr return_type; - std::map> local; - std::vector inits; + IDPtr scope_id; + std::unique_ptr> attrs; + TypePtr return_type; + std::map> local; + std::vector inits; }; // If no_global is true, don't search in the default "global" namespace. -extern const zeek::detail::IDPtr& lookup_ID( +extern const IDPtr& lookup_ID( const char* name, const char* module, bool no_global = false, bool same_module_only = false, bool check_export = true); -extern zeek::detail::IDPtr install_ID( +extern IDPtr install_ID( const char* name, const char* module_name, bool is_global, bool is_export); -extern void push_scope(zeek::detail::IDPtr id, - std::unique_ptr> attrs); +extern void push_scope(IDPtr id, std::unique_ptr> attrs); extern void push_existing_scope(Scope* scope); // Returns the one popped off. diff --git a/src/ScriptCoverageManager.cc b/src/ScriptCoverageManager.cc index c153ac546f..6bc93c00c8 100644 --- a/src/ScriptCoverageManager.cc +++ b/src/ScriptCoverageManager.cc @@ -28,18 +28,18 @@ ScriptCoverageManager::~ScriptCoverageManager() Unref(s); } -void ScriptCoverageManager::AddStmt(zeek::detail::Stmt* s) +void ScriptCoverageManager::AddStmt(Stmt* s) { if ( ignoring != 0 ) return; - zeek::Ref(s); + Ref(s); stmts.push_back(s); } bool ScriptCoverageManager::ReadStats() { - char* bf = zeek::util::zeekenv("ZEEK_PROFILER_FILE"); + char* bf = util::zeekenv("ZEEK_PROFILER_FILE"); if ( ! bf ) return false; @@ -56,7 +56,7 @@ bool ScriptCoverageManager::ReadStats() ss.clear(); std::vector lines; - zeek::util::tokenize_string(file_contents, "\n", &lines); + util::tokenize_string(file_contents, "\n", &lines); string delimiter; delimiter = delim; @@ -66,7 +66,7 @@ bool ScriptCoverageManager::ReadStats() continue; std::vector line_components; - zeek::util::tokenize_string(line, delimiter, &line_components); + util::tokenize_string(line, delimiter, &line_components); if ( line_components.size() != 3 ) { @@ -80,7 +80,7 @@ bool ScriptCoverageManager::ReadStats() pair location_desc(std::move(location), std::move(desc)); uint64_t count; - zeek::util::atoi_n(cnt.size(), cnt.c_str(), nullptr, 10, count); + util::atoi_n(cnt.size(), cnt.c_str(), nullptr, 10, count); usage_map.emplace(std::move(location_desc), count); } @@ -89,16 +89,16 @@ bool ScriptCoverageManager::ReadStats() bool ScriptCoverageManager::WriteStats() { - char* bf = zeek::util::zeekenv("ZEEK_PROFILER_FILE"); + char* bf = util::zeekenv("ZEEK_PROFILER_FILE"); if ( ! bf ) return false; - zeek::util::SafeDirname dirname{bf}; + util::SafeDirname dirname{bf}; - if ( ! zeek::util::detail::ensure_intermediate_dirs(dirname.result.data()) ) + if ( ! util::detail::ensure_intermediate_dirs(dirname.result.data()) ) { - zeek::reporter->Error("Failed to open ZEEK_PROFILER_FILE destination '%s' for writing", bf); + reporter->Error("Failed to open ZEEK_PROFILER_FILE destination '%s' for writing", bf); return false; } @@ -113,7 +113,7 @@ bool ScriptCoverageManager::WriteStats() if ( fd == -1 ) { - zeek::reporter->Error("Failed to generate unique file name from ZEEK_PROFILER_FILE: %s", bf); + reporter->Error("Failed to generate unique file name from ZEEK_PROFILER_FILE: %s", bf); return false; } f = fdopen(fd, "w"); @@ -125,11 +125,11 @@ bool ScriptCoverageManager::WriteStats() if ( ! f ) { - zeek::reporter->Error("Failed to open ZEEK_PROFILER_FILE destination '%s' for writing", bf); + reporter->Error("Failed to open ZEEK_PROFILER_FILE destination '%s' for writing", bf); return false; } - for ( list::const_iterator it = stmts.begin(); + for ( list::const_iterator it = stmts.begin(); it != stmts.end(); ++it ) { ODesc location_info; diff --git a/src/ScriptCoverageManager.h b/src/ScriptCoverageManager.h index 229065bd0f..d1c206b36a 100644 --- a/src/ScriptCoverageManager.h +++ b/src/ScriptCoverageManager.h @@ -42,13 +42,13 @@ public: void IncIgnoreDepth() { ignoring++; } void DecIgnoreDepth() { ignoring--; } - void AddStmt(zeek::detail::Stmt* s); + void AddStmt(Stmt* s); private: /** * The current, global ScriptCoverageManager instance creates this list at parse-time. */ - std::list stmts; + std::list stmts; /** * Indicates whether new statments will not be considered as part of diff --git a/src/SerializationFormat.cc b/src/SerializationFormat.cc index e41aaaf778..5ea915369c 100644 --- a/src/SerializationFormat.cc +++ b/src/SerializationFormat.cc @@ -45,7 +45,7 @@ void SerializationFormat::StartWrite() if ( ! output ) { - output = (char*)zeek::util::safe_malloc(INITIAL_SIZE); + output = (char*)util::safe_malloc(INITIAL_SIZE); output_size = INITIAL_SIZE; } @@ -67,7 +67,7 @@ bool SerializationFormat::ReadData(void* b, size_t count) { if ( input_pos + count > input_len ) { - zeek::reporter->Error("data underflow during read in binary format"); + reporter->Error("data underflow during read in binary format"); abort(); return false; } @@ -85,7 +85,7 @@ bool SerializationFormat::WriteData(const void* b, size_t count) while ( output_pos + count > output_size ) output_size *= GROWTH_FACTOR; - output = (char*)zeek::util::safe_realloc(output, output_size); + output = (char*)util::safe_realloc(output, output_size); memcpy(output + output_pos, b, count); output_pos += count; @@ -109,7 +109,7 @@ bool BinarySerializationFormat::Read(int* v, const char* tag) return false; *v = (int) ntohl(tmp); - DBG_LOG(zeek::DBG_SERIAL, "Read int %d [%s]", *v, tag); + DBG_LOG(DBG_SERIAL, "Read int %d [%s]", *v, tag); return true; } @@ -119,7 +119,7 @@ bool BinarySerializationFormat::Read(uint16_t* v, const char* tag) return false; *v = ntohs(*v); - DBG_LOG(zeek::DBG_SERIAL, "Read uint16_t %hu [%s]", *v, tag); + DBG_LOG(DBG_SERIAL, "Read uint16_t %hu [%s]", *v, tag); return true; } @@ -129,7 +129,7 @@ bool BinarySerializationFormat::Read(uint32_t* v, const char* tag) return false; *v = ntohl(*v); - DBG_LOG(zeek::DBG_SERIAL, "Read uint32_t %" PRIu32 " [%s]", *v, tag); + DBG_LOG(DBG_SERIAL, "Read uint32_t %" PRIu32 " [%s]", *v, tag); return true; } @@ -141,7 +141,7 @@ bool BinarySerializationFormat::Read(int64_t* v, const char* tag) return false; *v = ((int64_t(ntohl(x[0]))) << 32) | ntohl(x[1]); - DBG_LOG(zeek::DBG_SERIAL, "Read int64_t %" PRId64 " [%s]", *v, tag); + DBG_LOG(DBG_SERIAL, "Read int64_t %" PRId64 " [%s]", *v, tag); return true; } @@ -152,7 +152,7 @@ bool BinarySerializationFormat::Read(uint64_t* v, const char* tag) return false; *v = ((uint64_t(ntohl(x[0]))) << 32) | ntohl(x[1]); - DBG_LOG(zeek::DBG_SERIAL, "Read uint64_t %" PRIu64 " [%s]", *v, tag); + DBG_LOG(DBG_SERIAL, "Read uint64_t %" PRIu64 " [%s]", *v, tag); return true; } @@ -163,7 +163,7 @@ bool BinarySerializationFormat::Read(bool* v, const char* tag) return false; *v = c == '\1' ? true : false; - DBG_LOG(zeek::DBG_SERIAL, "Read bool %s [%s]", *v ? "true" : "false", tag); + DBG_LOG(DBG_SERIAL, "Read bool %s [%s]", *v ? "true" : "false", tag); return true; } @@ -173,14 +173,14 @@ bool BinarySerializationFormat::Read(double* d, const char* tag) return false; *d = ntohd(*d); - DBG_LOG(zeek::DBG_SERIAL, "Read double %.6f [%s]", *d, tag); + DBG_LOG(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(zeek::DBG_SERIAL, "Read char %s [%s]", zeek::util::fmt_bytes(v, 1), tag); + DBG_LOG(DBG_SERIAL, "Read char %s [%s]", util::fmt_bytes(v, 1), tag); return ret; } @@ -209,7 +209,7 @@ bool BinarySerializationFormat::Read(char** str, int* len, const char* tag) for ( int i = 0; i < l; i++ ) if ( ! s[i] ) { - zeek::reporter->Error("binary Format: string contains null; replaced by '_'"); + reporter->Error("binary Format: string contains null; replaced by '_'"); s[i] = '_'; } } @@ -218,7 +218,7 @@ bool BinarySerializationFormat::Read(char** str, int* len, const char* tag) *str = s; - DBG_LOG(zeek::DBG_SERIAL, "Read %d bytes |%s| [%s]", l, zeek::util::fmt_bytes(*str, l), tag); + DBG_LOG(DBG_SERIAL, "Read %d bytes |%s| [%s]", l, util::fmt_bytes(*str, l), tag); return true; } @@ -236,7 +236,7 @@ bool BinarySerializationFormat::Read(std::string* v, const char* tag) return true; } -bool BinarySerializationFormat::Read(zeek::IPAddr* addr, const char* tag) +bool BinarySerializationFormat::Read(IPAddr* addr, const char* tag) { int n = 0; if ( ! Read(&n, "addr-len") ) @@ -256,22 +256,22 @@ bool BinarySerializationFormat::Read(zeek::IPAddr* addr, const char* tag) } if ( n == 1 ) - *addr = zeek::IPAddr(IPv4, raw, zeek::IPAddr::Network); + *addr = IPAddr(IPv4, raw, IPAddr::Network); else - *addr = zeek::IPAddr(IPv6, raw, zeek::IPAddr::Network); + *addr = IPAddr(IPv6, raw, IPAddr::Network); return true; } -bool BinarySerializationFormat::Read(zeek::IPPrefix* prefix, const char* tag) +bool BinarySerializationFormat::Read(IPPrefix* prefix, const char* tag) { - zeek::IPAddr addr; + IPAddr addr; int len; if ( ! (Read(&addr, "prefix") && Read(&len, "width")) ) return false; - *prefix = zeek::IPPrefix(addr, len); + *prefix = IPPrefix(addr, len); return true; } @@ -303,34 +303,34 @@ bool BinarySerializationFormat::Read(struct in6_addr* addr, const char* tag) bool BinarySerializationFormat::Write(char v, const char* tag) { - DBG_LOG(zeek::DBG_SERIAL, "Write char %s [%s]", zeek::util::fmt_bytes(&v, 1), tag); + DBG_LOG(DBG_SERIAL, "Write char %s [%s]", util::fmt_bytes(&v, 1), tag); return WriteData(&v, 1); } bool BinarySerializationFormat::Write(uint16_t v, const char* tag) { - DBG_LOG(zeek::DBG_SERIAL, "Write uint16_t %hu [%s]", v, tag); + DBG_LOG(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(zeek::DBG_SERIAL, "Write uint32_t %" PRIu32 " [%s]", v, tag); + DBG_LOG(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(zeek::DBG_SERIAL, "Write int %d [%s]", v, tag); + DBG_LOG(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(zeek::DBG_SERIAL, "Write uint64_t %" PRIu64 " [%s]", v, tag); + DBG_LOG(DBG_SERIAL, "Write uint64_t %" PRIu64 " [%s]", v, tag); uint32_t x[2]; x[0] = htonl(v >> 32); x[1] = htonl(v & 0xffffffff); @@ -339,7 +339,7 @@ bool BinarySerializationFormat::Write(uint64_t v, const char* tag) bool BinarySerializationFormat::Write(int64_t v, const char* tag) { - DBG_LOG(zeek::DBG_SERIAL, "Write int64_t %" PRId64 " [%s]", v, tag); + DBG_LOG(DBG_SERIAL, "Write int64_t %" PRId64 " [%s]", v, tag); uint32_t x[2]; x[0] = htonl(v >> 32); x[1] = htonl(v & 0xffffffff); @@ -348,14 +348,14 @@ bool BinarySerializationFormat::Write(int64_t v, const char* tag) bool BinarySerializationFormat::Write(double d, const char* tag) { - DBG_LOG(zeek::DBG_SERIAL, "Write double %.6f [%s]", d, tag); + DBG_LOG(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(zeek::DBG_SERIAL, "Write bool %s [%s]", v ? "true" : "false", tag); + DBG_LOG(DBG_SERIAL, "Write bool %s [%s]", v ? "true" : "false", tag); char c = v ? '\1' : '\0'; return WriteData(&c, 1); } @@ -370,7 +370,7 @@ bool BinarySerializationFormat::Write(const std::string& s, const char* tag) return Write(s.data(), s.size(), tag); } -bool BinarySerializationFormat::Write(const zeek::IPAddr& addr, const char* tag) +bool BinarySerializationFormat::Write(const IPAddr& addr, const char* tag) { const uint32_t* raw; int n = addr.GetBytes(&raw); @@ -389,7 +389,7 @@ bool BinarySerializationFormat::Write(const zeek::IPAddr& addr, const char* tag) return true; } -bool BinarySerializationFormat::Write(const zeek::IPPrefix& prefix, const char* tag) +bool BinarySerializationFormat::Write(const IPPrefix& prefix, const char* tag) { return Write(prefix.Prefix(), "prefix") && Write(prefix.Length(), "width"); } @@ -434,7 +434,7 @@ bool BinarySerializationFormat::WriteSeparator() bool BinarySerializationFormat::Write(const char* buf, int len, const char* tag) { - DBG_LOG(zeek::DBG_SERIAL, "Write bytes |%s| [%s]", zeek::util::fmt_bytes(buf, len), tag); + DBG_LOG(DBG_SERIAL, "Write bytes |%s| [%s]", util::fmt_bytes(buf, len), tag); uint32_t l = htonl(len); return WriteData(&l, sizeof(l)) && WriteData(buf, len); } diff --git a/src/SerializationFormat.h b/src/SerializationFormat.h index d0f9ffe1a7..584fcc9aba 100644 --- a/src/SerializationFormat.h +++ b/src/SerializationFormat.h @@ -34,8 +34,8 @@ public: virtual bool Read(bool* v, const char* tag) = 0; virtual bool Read(double* d, const char* tag) = 0; virtual bool Read(std::string* s, const char* tag) = 0; - virtual bool Read(zeek::IPAddr* addr, const char* tag) = 0; - virtual bool Read(zeek::IPPrefix* prefix, const char* tag) = 0; + virtual bool Read(IPAddr* addr, const char* tag) = 0; + virtual bool Read(IPPrefix* prefix, const char* tag) = 0; virtual bool Read(in_addr* addr, const char* tag) = 0; virtual bool Read(in6_addr* addr, const char* tag) = 0; @@ -68,8 +68,8 @@ public: virtual bool Write(const char* s, const char* tag) = 0; virtual bool Write(const char* buf, int len, const char* tag) = 0; virtual bool Write(const std::string& s, const char* tag) = 0; - virtual bool Write(const zeek::IPAddr& addr, const char* tag) = 0; - virtual bool Write(const zeek::IPPrefix& prefix, const char* tag) = 0; + virtual bool Write(const IPAddr& addr, const char* tag) = 0; + virtual bool Write(const IPPrefix& prefix, const char* tag) = 0; virtual bool Write(const in_addr& addr, const char* tag) = 0; virtual bool Write(const in6_addr& addr, const char* tag) = 0; @@ -113,8 +113,8 @@ public: bool Read(double* d, const char* tag) override; bool Read(char** str, int* len, const char* tag) override; bool Read(std::string* s, const char* tag) override; - bool Read(zeek::IPAddr* addr, const char* tag) override; - bool Read(zeek::IPPrefix* prefix, const char* tag) override; + bool Read(IPAddr* addr, const char* tag) override; + bool Read(IPPrefix* prefix, const char* tag) override; bool Read(in_addr* addr, const char* tag) override; bool Read(in6_addr* addr, const char* tag) override; bool Write(int v, const char* tag) override; @@ -128,8 +128,8 @@ public: bool Write(const char* s, const char* tag) override; bool Write(const char* buf, int len, const char* tag) override; bool Write(const std::string& s, const char* tag) override; - bool Write(const zeek::IPAddr& addr, const char* tag) override; - bool Write(const zeek::IPPrefix& prefix, const char* tag) override; + bool Write(const IPAddr& addr, const char* tag) override; + bool Write(const IPPrefix& prefix, const char* tag) override; bool Write(const in_addr& addr, const char* tag) override; bool Write(const in6_addr& addr, const char* tag) override; bool WriteOpenTag(const char* tag) override; diff --git a/src/Sessions.cc b/src/Sessions.cc index ebf478a16d..afe817e2b5 100644 --- a/src/Sessions.cc +++ b/src/Sessions.cc @@ -58,13 +58,13 @@ void IPTunnelTimer::Dispatch(double t, bool is_expire) double last_active = it->second.second; double inactive_time = t > last_active ? t - last_active : 0; - if ( inactive_time >= zeek::BifConst::Tunnel::ip_tunnel_timeout ) + if ( inactive_time >= BifConst::Tunnel::ip_tunnel_timeout ) // tunnel activity timed out, delete it from map sessions->ip_tunnels.erase(tunnel_idx); else if ( ! is_expire ) // tunnel activity didn't timeout, schedule another timer - zeek::detail::timer_mgr->Add(new IPTunnelTimer(t, tunnel_idx)); + timer_mgr->Add(new IPTunnelTimer(t, tunnel_idx)); } } // namespace detail @@ -72,11 +72,11 @@ void IPTunnelTimer::Dispatch(double t, bool is_expire) NetSessions::NetSessions() { if ( stp_correlate_pair ) - stp_manager = new zeek::analyzer::stepping_stone::SteppingStoneManager(); + stp_manager = new analyzer::stepping_stone::SteppingStoneManager(); else stp_manager = nullptr; - discarder = new zeek::detail::Discarder(); + discarder = new detail::Discarder(); if ( ! discarder->IsActive() ) { delete discarder; @@ -87,17 +87,17 @@ NetSessions::NetSessions() dump_this_packet = false; num_packets_processed = 0; - static auto pkt_profile_file = zeek::id::find_val("pkt_profile_file"); + static auto pkt_profile_file = id::find_val("pkt_profile_file"); - if ( zeek::detail::pkt_profile_mode && zeek::detail::pkt_profile_freq > 0 && pkt_profile_file ) - pkt_profiler = new zeek::detail::PacketProfiler(zeek::detail::pkt_profile_mode, - zeek::detail::pkt_profile_freq, - pkt_profile_file->AsFile()); + if ( detail::pkt_profile_mode && detail::pkt_profile_freq > 0 && pkt_profile_file ) + pkt_profiler = new detail::PacketProfiler(detail::pkt_profile_mode, + detail::pkt_profile_freq, + pkt_profile_file->AsFile()); else pkt_profiler = nullptr; if ( arp_request || arp_reply || bad_arp ) - arp_analyzer = new zeek::analyzer::arp::ARP_Analyzer(); + arp_analyzer = new analyzer::arp::ARP_Analyzer(); else arp_analyzer = nullptr; @@ -126,12 +126,12 @@ void NetSessions::Done() { } -void NetSessions::NextPacket(double t, const zeek::Packet* pkt) +void NetSessions::NextPacket(double t, const Packet* pkt) { - zeek::detail::SegmentProfiler prof(zeek::detail::segment_logger, "dispatching-packet"); + detail::SegmentProfiler prof(detail::segment_logger, "dispatching-packet"); if ( raw_packet ) - zeek::event_mgr.Enqueue(raw_packet, pkt->ToRawPktHdrVal()); + event_mgr.Enqueue(raw_packet, pkt->ToRawPktHdrVal()); if ( pkt_profiler ) pkt_profiler->ProfilePkt(t, pkt->cap_len); @@ -151,7 +151,7 @@ void NetSessions::NextPacket(double t, const zeek::Packet* pkt) uint32_t caplen = pkt->cap_len - pkt->hdr_size; - if ( pkt->l3_proto == zeek::L3_IPV4 ) + if ( pkt->l3_proto == L3_IPV4 ) { if ( caplen < sizeof(struct ip) ) { @@ -160,11 +160,11 @@ void NetSessions::NextPacket(double t, const zeek::Packet* pkt) } const struct ip* ip = (const struct ip*) (pkt->data + pkt->hdr_size); - zeek::IP_Hdr ip_hdr(ip, false); + IP_Hdr ip_hdr(ip, false); DoNextPacket(t, pkt, &ip_hdr, nullptr); } - else if ( pkt->l3_proto == zeek::L3_IPV6 ) + else if ( pkt->l3_proto == L3_IPV6 ) { if ( caplen < sizeof(struct ip6_hdr) ) { @@ -172,11 +172,11 @@ void NetSessions::NextPacket(double t, const zeek::Packet* pkt) return; } - zeek::IP_Hdr ip_hdr((const struct ip6_hdr*) (pkt->data + pkt->hdr_size), false, caplen); + IP_Hdr ip_hdr((const struct ip6_hdr*) (pkt->data + pkt->hdr_size), false, caplen); DoNextPacket(t, pkt, &ip_hdr, nullptr); } - else if ( pkt->l3_proto == zeek::L3_ARP ) + else if ( pkt->l3_proto == L3_ARP ) { if ( arp_analyzer ) arp_analyzer->NextPacket(t, pkt); @@ -218,7 +218,7 @@ static unsigned int gre_header_len(uint16_t flags) return len; } -void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP_Hdr* ip_hdr, +void NetSessions::DoNextPacket(double t, const Packet* pkt, const IP_Hdr* ip_hdr, const EncapsulationStack* encapsulation) { uint32_t caplen = pkt->cap_len - pkt->hdr_size; @@ -305,7 +305,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP else { f = NextFragment(t, ip_hdr, pkt->data + pkt->hdr_size); - const zeek::IP_Hdr* ih = f->ReassembledPkt(); + const IP_Hdr* ih = f->ReassembledPkt(); if ( ! ih ) // It didn't reassemble into anything yet. return; @@ -335,7 +335,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP { dump_this_packet = true; if ( esp_packet ) - zeek::event_mgr.Enqueue(esp_packet, ip_hdr->ToPktHdrVal()); + event_mgr.Enqueue(esp_packet, ip_hdr->ToPktHdrVal()); // Can't do more since upper-layer payloads are going to be encrypted. return; @@ -355,7 +355,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP } if ( mobile_ipv6_message ) - zeek::event_mgr.Enqueue(mobile_ipv6_message, ip_hdr->ToPktHdrVal()); + event_mgr.Enqueue(mobile_ipv6_message, ip_hdr->ToPktHdrVal()); if ( ip_hdr->NextProto() != IPPROTO_NONE ) Weird("mobility_piggyback", pkt, encapsulation); @@ -404,9 +404,9 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP const struct icmp* icmpp = (const struct icmp *) data; id.src_port = icmpp->icmp_type; - id.dst_port = zeek::analyzer::icmp::ICMP4_counterpart(icmpp->icmp_type, - icmpp->icmp_code, - id.is_one_way); + id.dst_port = analyzer::icmp::ICMP4_counterpart(icmpp->icmp_type, + icmpp->icmp_code, + id.is_one_way); id.src_port = htons(id.src_port); id.dst_port = htons(id.dst_port); @@ -420,9 +420,9 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP const struct icmp* icmpp = (const struct icmp *) data; id.src_port = icmpp->icmp_type; - id.dst_port = zeek::analyzer::icmp::ICMP6_counterpart(icmpp->icmp_type, - icmpp->icmp_code, - id.is_one_way); + id.dst_port = analyzer::icmp::ICMP6_counterpart(icmpp->icmp_type, + icmpp->icmp_code, + id.is_one_way); id.src_port = htons(id.src_port); id.dst_port = htons(id.dst_port); @@ -433,7 +433,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP case IPPROTO_GRE: { - if ( ! zeek::BifConst::Tunnel::enable_gre ) + if ( ! BifConst::Tunnel::enable_gre ) { Weird("GRE_tunnel", ip_hdr, encapsulation); return; @@ -451,7 +451,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP if ( gre_version != 0 && gre_version != 1 ) { Weird("unknown_gre_version", ip_hdr, encapsulation, - zeek::util::fmt("%d", gre_version)); + util::fmt("%d", gre_version)); return; } @@ -529,7 +529,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP { // Enhanced GRE payload must be PPP. Weird("egre_protocol_type", ip_hdr, encapsulation, - zeek::util::fmt("%d", proto_typ)); + util::fmt("%d", proto_typ)); return; } } @@ -585,20 +585,20 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP case IPPROTO_IPV4: case IPPROTO_IPV6: { - if ( ! zeek::BifConst::Tunnel::enable_ip ) + if ( ! BifConst::Tunnel::enable_ip ) { Weird("IP_tunnel", ip_hdr, encapsulation); return; } if ( encapsulation && - encapsulation->Depth() >= zeek::BifConst::Tunnel::max_depth ) + encapsulation->Depth() >= BifConst::Tunnel::max_depth ) { Weird("exceeded_tunnel_max_depth", ip_hdr, encapsulation); return; } - zeek::IP_Hdr* inner = nullptr; + IP_Hdr* inner = nullptr; if ( gre_version != 0 ) { @@ -633,8 +633,8 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP { EncapsulatingConn ec(ip_hdr->SrcAddr(), ip_hdr->DstAddr(), tunnel_type); - ip_tunnels[tunnel_idx] = TunnelActivity(ec, zeek::run_state::network_time); - zeek::detail::timer_mgr->Add(new detail::IPTunnelTimer(zeek::run_state::network_time, tunnel_idx)); + ip_tunnels[tunnel_idx] = TunnelActivity(ec, run_state::network_time); + detail::timer_mgr->Add(new detail::IPTunnelTimer(run_state::network_time, tunnel_idx)); } else it->second.second = zeek::run_state::network_time; @@ -662,11 +662,11 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP } default: - Weird("unknown_protocol", pkt, encapsulation, zeek::util::fmt("%d", proto)); + Weird("unknown_protocol", pkt, encapsulation, util::fmt("%d", proto)); return; } - zeek::detail::ConnIDKey key = zeek::detail::BuildConnIDKey(id); + detail::ConnIDKey key = detail::BuildConnIDKey(id); Connection* conn = nullptr; // FIXME: The following is getting pretty complex. Need to split up @@ -710,7 +710,7 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP conn->CheckFlowLabel(is_orig, ip_hdr->FlowLabel()); - zeek::ValPtr pkt_hdr_val; + ValPtr pkt_hdr_val; if ( ipv6_ext_headers && ip_hdr->NumHeaders() > 1 ) { @@ -745,8 +745,8 @@ void NetSessions::DoNextPacket(double t, const zeek::Packet* pkt, const zeek::IP } } -void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, - const zeek::IP_Hdr* inner, const EncapsulationStack* prev, +void NetSessions::DoNextInnerPacket(double t, const Packet* pkt, + const IP_Hdr* inner, const EncapsulationStack* prev, const EncapsulatingConn& ec) { uint32_t caplen, len; @@ -759,9 +759,9 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, ts = pkt->ts; else { - ts.tv_sec = (time_t) zeek::run_state::network_time; + ts.tv_sec = (time_t) run_state::network_time; ts.tv_usec = (suseconds_t) - ((zeek::run_state::network_time - (double)ts.tv_sec) * 1000000); + ((run_state::network_time - (double)ts.tv_sec) * 1000000); } const u_char* data = nullptr; @@ -776,7 +776,7 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, outer->Add(ec); // Construct fake packet for DoNextPacket - zeek::Packet p; + Packet p; p.Init(DLT_RAW, &ts, caplen, len, data, false, ""); DoNextPacket(t, &p, inner, outer); @@ -785,7 +785,7 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, delete outer; } -void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, +void NetSessions::DoNextInnerPacket(double t, const Packet* pkt, uint32_t caplen, uint32_t len, const u_char* data, int link_type, const EncapsulationStack* prev, @@ -797,9 +797,9 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, ts = pkt->ts; else { - ts.tv_sec = (time_t) zeek::run_state::network_time; + ts.tv_sec = (time_t) run_state::network_time; ts.tv_usec = (suseconds_t) - ((zeek::run_state::network_time - (double)ts.tv_sec) * 1000000); + ((run_state::network_time - (double)ts.tv_sec) * 1000000); } EncapsulationStack* outer = prev ? @@ -807,10 +807,10 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, outer->Add(ec); // Construct fake packet for DoNextPacket - zeek::Packet p; + Packet p; p.Init(link_type, &ts, caplen, len, data, false, ""); - if ( p.Layer2Valid() && (p.l3_proto == zeek::L3_IPV4 || p.l3_proto == zeek::L3_IPV6) ) + if ( p.Layer2Valid() && (p.l3_proto == L3_IPV4 || p.l3_proto == L3_IPV6) ) { auto inner = p.IP(); DoNextPacket(t, &p, &inner, outer); @@ -820,7 +820,7 @@ void NetSessions::DoNextInnerPacket(double t, const zeek::Packet* pkt, } int NetSessions::ParseIPPacket(int caplen, const u_char* const pkt, int proto, - zeek::IP_Hdr*& inner) + IP_Hdr*& inner) { if ( proto == IPPROTO_IPV6 ) { @@ -828,7 +828,7 @@ int NetSessions::ParseIPPacket(int caplen, const u_char* const pkt, int proto, return -1; const struct ip6_hdr* ip6 = (const struct ip6_hdr*) pkt; - inner = new zeek::IP_Hdr(ip6, false, caplen); + inner = new IP_Hdr(ip6, false, caplen); if ( ( ip6->ip6_ctlun.ip6_un2_vfc & 0xF0 ) != 0x60 ) return -2; } @@ -839,14 +839,14 @@ int NetSessions::ParseIPPacket(int caplen, const u_char* const pkt, int proto, return -1; const struct ip* ip4 = (const struct ip*) pkt; - inner = new zeek::IP_Hdr(ip4, false); + inner = new IP_Hdr(ip4, false); if ( ip4->ip_v != 4 ) return -2; } else { - zeek::reporter->InternalWarning("Bad IP protocol version in ParseIPPacket"); + reporter->InternalWarning("Bad IP protocol version in ParseIPPacket"); return -1; } @@ -857,7 +857,7 @@ int NetSessions::ParseIPPacket(int caplen, const u_char* const pkt, int proto, } bool NetSessions::CheckHeaderTrunc(int proto, uint32_t len, uint32_t caplen, - const zeek::Packet* p, const EncapsulationStack* encap) + const Packet* p, const EncapsulationStack* encap) { uint32_t min_hdr_len = 0; switch ( proto ) { @@ -902,7 +902,7 @@ bool NetSessions::CheckHeaderTrunc(int proto, uint32_t len, uint32_t caplen, return false; } -detail::FragReassembler* NetSessions::NextFragment(double t, const zeek::IP_Hdr* ip, +detail::FragReassembler* NetSessions::NextFragment(double t, const IP_Hdr* ip, const u_char* pkt) { uint32_t frag_id = ip->ID(); @@ -927,19 +927,19 @@ detail::FragReassembler* NetSessions::NextFragment(double t, const zeek::IP_Hdr* return f; } -Connection* NetSessions::FindConnection(zeek::Val* v) +Connection* NetSessions::FindConnection(Val* v) { const auto& vt = v->GetType(); - if ( ! zeek::IsRecord(vt->Tag()) ) + if ( ! IsRecord(vt->Tag()) ) return nullptr; - zeek::RecordType* vr = vt->AsRecordType(); + RecordType* vr = vt->AsRecordType(); auto vl = v->AsRecord(); int orig_h, orig_p; // indices into record's value list int resp_h, resp_p; - if ( vr == zeek::id::conn_id ) + if ( vr == id::conn_id ) { orig_h = 0; orig_p = 1; @@ -962,11 +962,11 @@ Connection* NetSessions::FindConnection(zeek::Val* v) // types, too. } - const zeek::IPAddr& orig_addr = (*vl)[orig_h]->AsAddr(); - const zeek::IPAddr& resp_addr = (*vl)[resp_h]->AsAddr(); + const IPAddr& orig_addr = (*vl)[orig_h]->AsAddr(); + const IPAddr& resp_addr = (*vl)[resp_h]->AsAddr(); - zeek::PortVal* orig_portv = (*vl)[orig_p]->AsPortVal(); - zeek::PortVal* resp_portv = (*vl)[resp_p]->AsPortVal(); + PortVal* orig_portv = (*vl)[orig_p]->AsPortVal(); + PortVal* resp_portv = (*vl)[resp_p]->AsPortVal(); ConnID id; @@ -978,7 +978,7 @@ Connection* NetSessions::FindConnection(zeek::Val* v) id.is_one_way = false; // ### incorrect for ICMP connections - zeek::detail::ConnIDKey key = zeek::detail::BuildConnIDKey(id); + detail::ConnIDKey key = detail::BuildConnIDKey(id); ConnectionMap* d; if ( orig_portv->IsTCP() ) @@ -1007,15 +1007,15 @@ void NetSessions::Remove(Connection* c) { if ( c->IsKeyValid() ) { - const zeek::detail::ConnIDKey& key = c->Key(); + const detail::ConnIDKey& key = c->Key(); c->CancelTimers(); if ( c->ConnTransport() == TRANSPORT_TCP ) { - auto ta = static_cast(c->GetRootAnalyzer()); + auto ta = static_cast(c->GetRootAnalyzer()); assert(ta->IsAnalyzer("TCP")); - zeek::analyzer::tcp::TCP_Endpoint* to = ta->Orig(); - zeek::analyzer::tcp::TCP_Endpoint* tr = ta->Resp(); + analyzer::tcp::TCP_Endpoint* to = ta->Orig(); + analyzer::tcp::TCP_Endpoint* tr = ta->Resp(); tcp_stats.StateLeft(to->state, tr->state); } @@ -1031,21 +1031,21 @@ void NetSessions::Remove(Connection* c) switch ( c->ConnTransport() ) { case TRANSPORT_TCP: if ( tcp_conns.erase(key) == 0 ) - zeek::reporter->InternalWarning("connection missing"); + reporter->InternalWarning("connection missing"); break; case TRANSPORT_UDP: if ( udp_conns.erase(key) == 0 ) - zeek::reporter->InternalWarning("connection missing"); + reporter->InternalWarning("connection missing"); break; case TRANSPORT_ICMP: if ( icmp_conns.erase(key) == 0 ) - zeek::reporter->InternalWarning("connection missing"); + reporter->InternalWarning("connection missing"); break; case TRANSPORT_UNKNOWN: - zeek::reporter->InternalWarning("unknown transport when removing connection"); + reporter->InternalWarning("unknown transport when removing connection"); break; } @@ -1059,7 +1059,7 @@ void NetSessions::Remove(detail::FragReassembler* f) return; if ( fragments.erase(f->Key()) == 0 ) - zeek::reporter->InternalWarning("fragment reassembler not in dict"); + reporter->InternalWarning("fragment reassembler not in dict"); Unref(f); } @@ -1093,7 +1093,7 @@ void NetSessions::Insert(Connection* c) break; default: - zeek::reporter->InternalWarning("unknown connection type"); + reporter->InternalWarning("unknown connection type"); Unref(c); return; } @@ -1166,9 +1166,9 @@ void NetSessions::GetStats(SessionStats& s) const s.max_fragments = stats.max_fragments; } -Connection* NetSessions::NewConn(const zeek::detail::ConnIDKey& k, double t, const ConnID* id, +Connection* NetSessions::NewConn(const detail::ConnIDKey& k, double t, const ConnID* id, const u_char* data, int proto, uint32_t flow_label, - const zeek::Packet* pkt, const EncapsulationStack* encapsulation) + const Packet* pkt, const EncapsulationStack* encapsulation) { // FIXME: This should be cleaned up a bit, it's too protocol-specific. // But I'm not yet sure what the right abstraction for these things is. @@ -1192,7 +1192,7 @@ Connection* NetSessions::NewConn(const zeek::detail::ConnIDKey& k, double t, con tproto = TRANSPORT_ICMP; break; default: - zeek::reporter->InternalWarning("unknown transport protocol"); + reporter->InternalWarning("unknown transport protocol"); return nullptr; }; @@ -1213,7 +1213,7 @@ Connection* NetSessions::NewConn(const zeek::detail::ConnIDKey& k, double t, con if ( flip ) conn->FlipRoles(); - if ( ! zeek::analyzer_mgr->BuildInitialAnalyzerTree(conn) ) + if ( ! analyzer_mgr->BuildInitialAnalyzerTree(conn) ) { conn->Done(); Unref(conn); @@ -1226,7 +1226,7 @@ Connection* NetSessions::NewConn(const zeek::detail::ConnIDKey& k, double t, con return conn; } -Connection* NetSessions::LookupConn(const ConnectionMap& conns, const zeek::detail::ConnIDKey& key) +Connection* NetSessions::LookupConn(const ConnectionMap& conns, const detail::ConnIDKey& key) { auto it = conns.find(key); if ( it != conns.end() ) @@ -1243,7 +1243,7 @@ bool NetSessions::IsLikelyServerPort(uint32_t port, TransportProto proto) const if ( ! have_cache ) { - auto likely_server_ports = zeek::id::find_val("likely_server_ports"); + auto likely_server_ports = id::find_val("likely_server_ports"); auto lv = likely_server_ports->ToPureListVal(); for ( int i = 0; i < lv->Length(); i++ ) port_cache.insert(lv->Idx(i)->InternalUnsigned()); @@ -1309,49 +1309,49 @@ bool NetSessions::WantConnection(uint16_t src_port, uint16_t dst_port, return true; } -void NetSessions::DumpPacket(const zeek::Packet *pkt, int len) +void NetSessions::DumpPacket(const Packet *pkt, int len) { - if ( ! zeek::run_state::detail::pkt_dumper ) + if ( ! run_state::detail::pkt_dumper ) return; if ( len != 0 ) { if ( (uint32_t)len > pkt->cap_len ) - zeek::reporter->Warning("bad modified caplen"); + reporter->Warning("bad modified caplen"); else - const_cast(pkt)->cap_len = len; + const_cast(pkt)->cap_len = len; } - zeek::run_state::detail::pkt_dumper->Dump(pkt); + run_state::detail::pkt_dumper->Dump(pkt); } -void NetSessions::Weird(const char* name, const zeek::Packet* pkt, +void NetSessions::Weird(const char* name, const Packet* pkt, const EncapsulationStack* encap, const char* addl) { if ( pkt ) dump_this_packet = true; if ( encap && encap->LastType() != BifEnum::Tunnel::NONE ) - zeek::reporter->Weird(zeek::util::fmt("%s_in_tunnel", name), addl); + reporter->Weird(util::fmt("%s_in_tunnel", name), addl); else - zeek::reporter->Weird(name, addl); + reporter->Weird(name, addl); } -void NetSessions::Weird(const char* name, const zeek::IP_Hdr* ip, +void NetSessions::Weird(const char* name, const IP_Hdr* ip, const EncapsulationStack* encap, const char* addl) { if ( encap && encap->LastType() != BifEnum::Tunnel::NONE ) - zeek::reporter->Weird(ip->SrcAddr(), ip->DstAddr(), - zeek::util::fmt("%s_in_tunnel", name), addl); + reporter->Weird(ip->SrcAddr(), ip->DstAddr(), + util::fmt("%s_in_tunnel", name), addl); else - zeek::reporter->Weird(ip->SrcAddr(), ip->DstAddr(), name, addl); + reporter->Weird(ip->SrcAddr(), ip->DstAddr(), name, addl); } unsigned int NetSessions::ConnectionMemoryUsage() { unsigned int mem = 0; - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) // Connections have been flushed already. return 0; @@ -1371,7 +1371,7 @@ unsigned int NetSessions::ConnectionMemoryUsageConnVals() { unsigned int mem = 0; - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) // Connections have been flushed already. return 0; @@ -1389,7 +1389,7 @@ unsigned int NetSessions::ConnectionMemoryUsageConnVals() unsigned int NetSessions::MemoryAllocation() { - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) // Connections have been flushed already. return 0; @@ -1403,7 +1403,7 @@ unsigned int NetSessions::MemoryAllocation() ; } -void NetSessions::InsertConnection(ConnectionMap* m, const zeek::detail::ConnIDKey& key, Connection* conn) +void NetSessions::InsertConnection(ConnectionMap* m, const detail::ConnIDKey& key, Connection* conn) { (*m)[key] = conn; diff --git a/src/Sessions.h b/src/Sessions.h index a8b0c2132e..fe483ca0b8 100644 --- a/src/Sessions.h +++ b/src/Sessions.h @@ -54,19 +54,19 @@ public: ~NetSessions(); // Main entry point for packet processing. - void NextPacket(double t, const zeek::Packet* pkt); + void NextPacket(double t, const Packet* pkt); void Done(); // call to drain events before destructing // Returns a reassembled packet, or nil if there are still // some missing fragments. - detail::FragReassembler* NextFragment(double t, const zeek::IP_Hdr* ip, + detail::FragReassembler* NextFragment(double t, const IP_Hdr* ip, const u_char* pkt); // Looks up the connection referred to by the given Val, // which should be a conn_id record. Returns nil if there's // no such connection or the Val is ill-formed. - Connection* FindConnection(zeek::Val* v); + Connection* FindConnection(Val* v); void Remove(Connection* c); void Remove(detail::FragReassembler* f); @@ -82,27 +82,27 @@ public: void GetStats(SessionStats& s) const; - void Weird(const char* name, const zeek::Packet* pkt, - const zeek::EncapsulationStack* encap = nullptr, const char* addl = ""); - void Weird(const char* name, const zeek::IP_Hdr* ip, - const zeek::EncapsulationStack* encap = nullptr, const char* addl = ""); + void Weird(const char* name, const Packet* pkt, + const EncapsulationStack* encap = nullptr, const char* addl = ""); + void Weird(const char* name, const IP_Hdr* ip, + const EncapsulationStack* encap = nullptr, const char* addl = ""); - zeek::detail::PacketFilter* GetPacketFilter() + detail::PacketFilter* GetPacketFilter() { if ( ! packet_filter ) - packet_filter = new zeek::detail::PacketFilter(detail::packet_filter_default); + packet_filter = new detail::PacketFilter(detail::packet_filter_default); return packet_filter; } - zeek::analyzer::stepping_stone::SteppingStoneManager* GetSTPManager() { return stp_manager; } + analyzer::stepping_stone::SteppingStoneManager* GetSTPManager() { return stp_manager; } unsigned int CurrentConnections() { return tcp_conns.size() + udp_conns.size() + icmp_conns.size(); } - void DoNextPacket(double t, const zeek::Packet *pkt, const zeek::IP_Hdr* ip_hdr, - const zeek::EncapsulationStack* encapsulation); + void DoNextPacket(double t, const Packet *pkt, const IP_Hdr* ip_hdr, + const EncapsulationStack* encapsulation); /** * Wrapper that recurses on DoNextPacket for encapsulated IP packets. @@ -118,9 +118,9 @@ public: * the most-recently found depth of encapsulation. * @param ec The most-recently found depth of encapsulation. */ - void DoNextInnerPacket(double t, const zeek::Packet *pkt, - const zeek::IP_Hdr* inner, const zeek::EncapsulationStack* prev, - const zeek::EncapsulatingConn& ec); + void DoNextInnerPacket(double t, const Packet *pkt, + const IP_Hdr* inner, const EncapsulationStack* prev, + const EncapsulatingConn& ec); /** * Recurses on DoNextPacket for encapsulated Ethernet/IP packets. @@ -137,11 +137,11 @@ public: * including the most-recently found depth of encapsulation. * @param ec The most-recently found depth of encapsulation. */ - void DoNextInnerPacket(double t, const zeek::Packet* pkt, + void DoNextInnerPacket(double t, const Packet* pkt, uint32_t caplen, uint32_t len, const u_char* data, int link_type, - const zeek::EncapsulationStack* prev, - const zeek::EncapsulatingConn& ec); + const EncapsulationStack* prev, + const EncapsulatingConn& ec); /** * Returns a wrapper IP_Hdr object if \a pkt appears to be a valid IPv4 @@ -166,25 +166,25 @@ public: * for other return values. */ int ParseIPPacket(int caplen, const u_char* const pkt, int proto, - zeek::IP_Hdr*& inner); + IP_Hdr*& inner); unsigned int ConnectionMemoryUsage(); unsigned int ConnectionMemoryUsageConnVals(); unsigned int MemoryAllocation(); - zeek::analyzer::tcp::TCPStateStats tcp_stats; // keeps statistics on TCP states + analyzer::tcp::TCPStateStats tcp_stats; // keeps statistics on TCP states protected: friend class ConnCompressor; friend class detail::IPTunnelTimer; - using ConnectionMap = std::map; + using ConnectionMap = std::map; using FragmentMap = std::map; - Connection* NewConn(const zeek::detail::ConnIDKey& k, double t, const ConnID* id, + Connection* NewConn(const detail::ConnIDKey& k, double t, const ConnID* id, const u_char* data, int proto, uint32_t flow_label, - const zeek::Packet* pkt, const zeek::EncapsulationStack* encapsulation); + const Packet* pkt, const EncapsulationStack* encapsulation); - Connection* LookupConn(const ConnectionMap& conns, const zeek::detail::ConnIDKey& key); + Connection* LookupConn(const ConnectionMap& conns, const detail::ConnIDKey& key); // Returns true if the port corresonds to an application // for which there's a Bro analyzer (even if it might not @@ -207,20 +207,20 @@ protected: // Record the given packet (if a dumper is active). If len=0 // then the whole packet is recorded, otherwise just the first // len bytes. - void DumpPacket(const zeek::Packet *pkt, int len=0); + void DumpPacket(const Packet *pkt, int len=0); // For a given protocol, checks whether the header's length as derived // from lower-level headers or the length actually captured is less // than that protocol's minimum header size. bool CheckHeaderTrunc(int proto, uint32_t len, uint32_t caplen, - const zeek::Packet *pkt, const zeek::EncapsulationStack* encap); + const Packet *pkt, const EncapsulationStack* encap); // Inserts a new connection into the sessions map. If a connection with // the same key already exists in the map, it will be overwritten by // the new one. Connection count stats get updated either way (so most // cases should likely check that the key is not already in the map to // avoid unnecessary incrementing of connecting counts). - void InsertConnection(ConnectionMap* m, const zeek::detail::ConnIDKey& key, Connection* conn); + void InsertConnection(ConnectionMap* m, const detail::ConnIDKey& key, Connection* conn); ConnectionMap tcp_conns; ConnectionMap udp_conns; @@ -229,28 +229,28 @@ protected: SessionStats stats; - using IPPair = std::pair; - using TunnelActivity = std::pair; + using IPPair = std::pair; + using TunnelActivity = std::pair; using IPTunnelMap = std::map; IPTunnelMap ip_tunnels; - zeek::analyzer::arp::ARP_Analyzer* arp_analyzer; + analyzer::arp::ARP_Analyzer* arp_analyzer; - zeek::analyzer::stepping_stone::SteppingStoneManager* stp_manager; - zeek::detail::Discarder* discarder; - zeek::detail::PacketFilter* packet_filter; + analyzer::stepping_stone::SteppingStoneManager* stp_manager; + detail::Discarder* discarder; + detail::PacketFilter* packet_filter; uint64_t num_packets_processed; - zeek::detail::PacketProfiler* pkt_profiler; + detail::PacketProfiler* pkt_profiler; bool dump_this_packet; // if true, current packet should be recorded }; namespace detail { -class IPTunnelTimer final : public zeek::detail::Timer { +class IPTunnelTimer final : public Timer { public: IPTunnelTimer(double t, NetSessions::IPPair p) - : zeek::detail::Timer(t + zeek::BifConst::Tunnel::ip_tunnel_timeout, - zeek::detail::TIMER_IP_TUNNEL_INACTIVITY), tunnel_idx(p) {} + : Timer(t + BifConst::Tunnel::ip_tunnel_timeout, + TIMER_IP_TUNNEL_INACTIVITY), tunnel_idx(p) {} ~IPTunnelTimer() override {} diff --git a/src/SmithWaterman.cc b/src/SmithWaterman.cc index b773283608..f3fe2c008e 100644 --- a/src/SmithWaterman.cc +++ b/src/SmithWaterman.cc @@ -14,7 +14,7 @@ namespace zeek::detail { Substring::Substring(const Substring& bst) -: zeek::String((const zeek::String&) bst), _num(), _new(bst._new) +: String((const String&) bst), _num(), _new(bst._new) { for ( BSSAlignVecCIt it = bst._aligns.begin(); it != bst._aligns.end(); ++it ) _aligns.push_back(*it); @@ -22,7 +22,7 @@ Substring::Substring(const Substring& bst) const Substring& Substring::operator=(const Substring& bst) { - zeek::String::operator=(bst); + String::operator=(bst); _aligns.clear(); @@ -34,7 +34,7 @@ const Substring& Substring::operator=(const Substring& bst) return *this; } -void Substring::AddAlignment(const zeek::String* str, int index) +void Substring::AddAlignment(const String* str, int index) { _aligns.push_back(BSSAlign(str, index)); } @@ -58,14 +58,14 @@ bool Substring::DoesCover(const Substring* bst) const return true; } -zeek::VectorVal* Substring::VecToPolicy(Vec* vec) +VectorVal* Substring::VecToPolicy(Vec* vec) { - static auto sw_substring_type = zeek::id::find_type("sw_substring"); - static auto sw_align_type = zeek::id::find_type("sw_align"); - static auto sw_align_vec_type = zeek::id::find_type("sw_align_vec"); - static auto sw_substring_vec_type = zeek::id::find_type("sw_substring_vec"); + static auto sw_substring_type = id::find_type("sw_substring"); + static auto sw_align_type = id::find_type("sw_align"); + static auto sw_align_vec_type = id::find_type("sw_align_vec"); + static auto sw_substring_vec_type = id::find_type("sw_substring_vec"); - auto result = zeek::make_intrusive(sw_substring_vec_type); + auto result = make_intrusive(sw_substring_vec_type); if ( vec ) { @@ -73,24 +73,24 @@ zeek::VectorVal* Substring::VecToPolicy(Vec* vec) { Substring* bst = (*vec)[i]; - auto st_val = zeek::make_intrusive(sw_substring_type); - st_val->Assign(0, zeek::make_intrusive(new zeek::String(*bst))); + auto st_val = make_intrusive(sw_substring_type); + st_val->Assign(0, make_intrusive(new String(*bst))); - auto aligns = zeek::make_intrusive(sw_align_vec_type); + auto aligns = make_intrusive(sw_align_vec_type); for ( unsigned int j = 0; j < bst->GetNumAlignments(); ++j ) { const BSSAlign& align = (bst->GetAlignments())[j]; - auto align_val = zeek::make_intrusive(sw_align_type); - align_val->Assign(0, zeek::make_intrusive(new zeek::String(*align.string))); - align_val->Assign(1, zeek::val_mgr->Count(align.index)); + auto align_val = make_intrusive(sw_align_type); + align_val->Assign(0, make_intrusive(new String(*align.string))); + align_val->Assign(1, val_mgr->Count(align.index)); aligns->Assign(j + 1, std::move(align_val)); } st_val->Assign(1, std::move(aligns)); - st_val->Assign(2, zeek::val_mgr->Bool(bst->IsNewAlignment())); + st_val->Assign(2, val_mgr->Bool(bst->IsNewAlignment())); result->Assign(i + 1, std::move(st_val)); } } @@ -98,7 +98,7 @@ zeek::VectorVal* Substring::VecToPolicy(Vec* vec) return result.release(); } -Substring::Vec* Substring::VecFromPolicy(zeek::VectorVal* vec) +Substring::Vec* Substring::VecFromPolicy(VectorVal* vec) { Vec* result = new Vec(); @@ -109,14 +109,14 @@ Substring::Vec* Substring::VecFromPolicy(zeek::VectorVal* vec) if ( ! v ) continue; - const zeek::String* str = v->AsRecordVal()->GetField(0)->AsString(); + const String* str = v->AsRecordVal()->GetField(0)->AsString(); auto* substr = new Substring(*str); - const zeek::VectorVal* aligns = v->AsRecordVal()->GetField(1)->AsVectorVal(); + const VectorVal* aligns = v->AsRecordVal()->GetField(1)->AsVectorVal(); for ( unsigned int j = 1; j <= aligns->Size(); ++j ) { - const zeek::RecordVal* align = aligns->AsVectorVal()->At(j)->AsRecordVal(); - const zeek::String* str = align->GetField(0)->AsString(); + const RecordVal* align = aligns->AsVectorVal()->At(j)->AsRecordVal(); + const String* str = align->GetField(0)->AsString(); int index = align->GetField(1)->AsCount(); substr->AddAlignment(str, index); } @@ -144,9 +144,9 @@ char* Substring::VecToString(Vec* vec) return strdup(result.c_str()); } -zeek::String::IdxVec* Substring::GetOffsetsVec(const Vec* vec, unsigned int index) +String::IdxVec* Substring::GetOffsetsVec(const Vec* vec, unsigned int index) { - zeek::String::IdxVec* result = new zeek::String::IdxVec(); + String::IdxVec* result = new String::IdxVec(); for ( VecCIt it = vec->begin(); it != vec->end(); ++it ) { @@ -174,7 +174,7 @@ bool SubstringCmp::operator()(const Substring* bst1, if ( _index >= bst1->GetNumAlignments() || _index >= bst2->GetNumAlignments() ) { - zeek::reporter->Warning("SubstringCmp::operator(): invalid index for input strings.\n"); + reporter->Warning("SubstringCmp::operator(): invalid index for input strings.\n"); return false; } @@ -211,7 +211,7 @@ struct SWNode { // class SWNodeMatrix { public: - SWNodeMatrix(const zeek::String* s1, const zeek::String* s2) + SWNodeMatrix(const String* s1, const String* s2) : _s1(s1), _s2(s2), _rows(s1->Len() + 1), _cols(s2->Len() + 1) { _nodes = new SWNode[_cols * _rows]; @@ -231,8 +231,8 @@ public: return &(_nodes[row * _cols + col]); } - const zeek::String* GetRowsString() const { return _s1; } - const zeek::String* GetColsString() const { return _s2; } + const String* GetRowsString() const { return _s1; } + const String* GetColsString() const { return _s2; } int GetHeight() const { return _rows; } int GetWidth() const { return _cols; } @@ -249,8 +249,8 @@ public: } private: - const zeek::String* _s1; - const zeek::String* _s2; + const String* _s1; + const String* _s2; int _rows, _cols; SWNode* _nodes; @@ -359,7 +359,7 @@ static void sw_collect_multiple(Substring::Vec* result, { if ( (*it2)->DoesCover(*it3) ) { - zeek::util::delete_each(new_al); + util::delete_each(new_al); delete new_al; new_al = nullptr; goto end_loop; @@ -367,7 +367,7 @@ static void sw_collect_multiple(Substring::Vec* result, if ( (*it3)->DoesCover(*it2) ) { - zeek::util::delete_each(old_al); + util::delete_each(old_al); delete old_al; *it = 0; goto end_loop; @@ -400,7 +400,7 @@ end_loop: // The main Smith-Waterman algorithm. // -Substring::Vec* smith_waterman(const zeek::String* s1, const zeek::String* s2, +Substring::Vec* smith_waterman(const String* s1, const String* s2, SWParams& params) { auto* result = new Substring::Vec(); @@ -417,8 +417,8 @@ Substring::Vec* smith_waterman(const zeek::String* s1, const zeek::String* s2, int row = 0, col = 0; - zeek::byte_vec string1 = s1->Bytes(); - zeek::byte_vec string2 = s2->Bytes(); + byte_vec string1 = s1->Bytes(); + byte_vec string2 = s2->Bytes(); SWNodeMatrix matrix(s1, s2); // dynamic programming matrix. SWNode* node_max = nullptr; // pointer to the best score's node diff --git a/src/SmithWaterman.h b/src/SmithWaterman.h index 2ed4d71753..bb3caa2865 100644 --- a/src/SmithWaterman.h +++ b/src/SmithWaterman.h @@ -13,7 +13,7 @@ namespace zeek::detail { * marked as being a common substring of arbitrarily many strings, for each * of which we store where the substring starts. */ -class Substring : public zeek::String { +class Substring : public String { public: typedef std::vector Vec; @@ -24,12 +24,12 @@ public: // struct BSSAlign { - BSSAlign(const zeek::String* string, int index) + BSSAlign(const String* string, int index) { this->string = string; this->index = index; } // The other string // - const zeek::String* string; + const String* string; // Offset in the string that substring // starts at, counting from 0. @@ -42,10 +42,10 @@ public: typedef BSSAlignVec::const_iterator BSSAlignVecCIt; explicit Substring(const std::string& string) - : zeek::String(string), _num(), _new(false) { } + : String(string), _num(), _new(false) { } - explicit Substring(const zeek::String& string) - : zeek::String(string), _num(), _new(false) { } + explicit Substring(const String& string) + : String(string), _num(), _new(false) { } Substring(const Substring& bst); @@ -58,7 +58,7 @@ public: // bool DoesCover(const Substring* bst) const; - void AddAlignment(const zeek::String* string, int index); + void AddAlignment(const String* string, int index); const BSSAlignVec& GetAlignments() const { return _aligns; } unsigned int GetNumAlignments() const { return _aligns.size(); } @@ -70,11 +70,10 @@ public: // Helper methods for vectors: // - static zeek::VectorVal* VecToPolicy(Vec* vec); - static Vec* VecFromPolicy(zeek::VectorVal* vec); + static VectorVal* VecToPolicy(Vec* vec); + static Vec* VecFromPolicy(VectorVal* vec); static char* VecToString(Vec* vec); - static zeek::String::IdxVec* GetOffsetsVec(const Vec* vec, - unsigned int index); + static String::IdxVec* GetOffsetsVec(const Vec* vec, unsigned int index); private: typedef std::map DataMap; @@ -150,8 +149,8 @@ struct SWParams { // input strings where the string occurs. On error, or if no common // subsequence exists, an empty vector is returned. // -extern Substring::Vec* smith_waterman(const zeek::String* s1, - const zeek::String* s2, +extern Substring::Vec* smith_waterman(const String* s1, + const String* s2, SWParams& params); } // namespace zeek::detail diff --git a/src/Stats.cc b/src/Stats.cc index 142c903926..8e421c483b 100644 --- a/src/Stats.cc +++ b/src/Stats.cc @@ -29,10 +29,10 @@ uint64_t& tot_gap_bytes = zeek::detail::tot_gap_bytes; namespace zeek::detail { -class ProfileTimer final : public zeek::detail::Timer { +class ProfileTimer final : public Timer { public: ProfileTimer(double t, ProfileLogger* l, double i) - : zeek::detail::Timer(t, zeek::detail::TIMER_PROFILE) + : Timer(t, TIMER_PROFILE) { logger = l; interval = i; @@ -51,17 +51,17 @@ void ProfileTimer::Dispatch(double t, bool is_expire) // Reinstall timer. if ( ! is_expire ) - zeek::detail::timer_mgr->Add(new ProfileTimer(zeek::run_state::network_time + interval, - logger, interval)); + timer_mgr->Add(new ProfileTimer(run_state::network_time + interval, + logger, interval)); } ProfileLogger::ProfileLogger(zeek::File* arg_file, double interval) -: SegmentStatsReporter() + : SegmentStatsReporter() { file = arg_file; log_count = 0; - zeek::detail::timer_mgr->Add(new ProfileTimer(1, this, interval)); + timer_mgr->Add(new ProfileTimer(1, this, interval)); } ProfileLogger::~ProfileLogger() @@ -71,11 +71,11 @@ ProfileLogger::~ProfileLogger() void ProfileLogger::Log() { - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) // Connections have been flushed already. return; - file->Write(zeek::util::fmt("%.06f ------------------------\n", zeek::run_state::network_time)); + file->Write(util::fmt("%.06f ------------------------\n", run_state::network_time)); // Do expensive profiling only occasionally. bool expensive = false; @@ -90,14 +90,14 @@ void ProfileLogger::Log() struct timeval tv_stime = r.ru_stime; uint64_t total, malloced; - zeek::util::get_memory_usage(&total, &malloced); + util::get_memory_usage(&total, &malloced); static unsigned int first_total = 0; static double first_rtime = 0; static double first_utime = 0; static double first_stime = 0; - double rtime = zeek::util::current_time(); + double rtime = util::current_time(); double utime = double(tv_utime.tv_sec) + double(tv_utime.tv_usec) / 1e6; double stime = double(tv_stime.tv_sec) + double(tv_stime.tv_usec) / 1e6; @@ -108,27 +108,27 @@ void ProfileLogger::Log() first_utime = utime; first_stime = stime; - file->Write(zeek::util::fmt("%.06f Command line: ", zeek::run_state::network_time )); + file->Write(util::fmt("%.06f Command line: ", run_state::network_time )); for ( int i = 0; i < zeek_argc; i++ ) { file->Write(zeek_argv[i]); file->Write(" "); } - file->Write(zeek::util::fmt("\n%.06f ------------------------\n", zeek::run_state::network_time)); + file->Write(util::fmt("\n%.06f ------------------------\n", run_state::network_time)); } - file->Write(zeek::util::fmt("%.06f Memory: total=%" PRId64 "K total_adj=%" PRId64 "K malloced: %" PRId64 "K\n", - zeek::run_state::network_time, total / 1024, (total - first_total) / 1024, + file->Write(util::fmt("%.06f Memory: total=%" PRId64 "K total_adj=%" PRId64 "K malloced: %" PRId64 "K\n", + run_state::network_time, total / 1024, (total - first_total) / 1024, malloced / 1024)); - file->Write(zeek::util::fmt("%.06f Run-time: user+sys=%.1f user=%.1f sys=%.1f real=%.1f\n", - zeek::run_state::network_time, (utime + stime) - (first_utime + first_stime), + file->Write(util::fmt("%.06f Run-time: user+sys=%.1f user=%.1f sys=%.1f real=%.1f\n", + run_state::network_time, (utime + stime) - (first_utime + first_stime), utime - first_utime, stime - first_stime, rtime - first_rtime)); int conn_mem_use = expensive ? sessions->ConnectionMemoryUsage() : 0; - file->Write(zeek::util::fmt("%.06f Conns: total=%" PRIu64 " current=%" PRIu64 "/%" PRIi32 " mem=%" PRIi32 "K avg=%.1f table=%" PRIu32 "K connvals=%" PRIu32 "K\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.06f Conns: total=%" PRIu64 " current=%" PRIu64 "/%" PRIi32 " mem=%" PRIi32 "K avg=%.1f table=%" PRIu32 "K connvals=%" PRIu32 "K\n", + run_state::network_time, Connection::TotalConnections(), Connection::CurrentConnections(), sessions->CurrentConnections(), @@ -141,20 +141,20 @@ void ProfileLogger::Log() SessionStats s; sessions->GetStats(s); - file->Write(zeek::util::fmt("%.06f Conns: tcp=%zu/%zu udp=%zu/%zu icmp=%zu/%zu\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.06f Conns: tcp=%zu/%zu udp=%zu/%zu icmp=%zu/%zu\n", + run_state::network_time, s.num_TCP_conns, s.max_TCP_conns, s.num_UDP_conns, s.max_UDP_conns, s.num_ICMP_conns, s.max_ICMP_conns )); sessions->tcp_stats.PrintStats(file, - zeek::util::fmt("%.06f TCP-States:", zeek::run_state::network_time)); + util::fmt("%.06f TCP-States:", run_state::network_time)); // Alternatively, if you prefer more compact output... /* - file->Write(zeek::util::fmt("%.8f TCP-States: I=%d S=%d SA=%d SR=%d E=%d EF=%d ER=%d F=%d P=%d\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.8f TCP-States: I=%d S=%d SA=%d SR=%d E=%d EF=%d ER=%d F=%d P=%d\n", + run_state::network_time, sessions->tcp_stats.StateInactive(), sessions->tcp_stats.StateRequest(), sessions->tcp_stats.StateSuccRequest(), @@ -167,61 +167,61 @@ void ProfileLogger::Log() )); */ - file->Write(zeek::util::fmt("%.06f Connections expired due to inactivity: %" PRIu64 "\n", - zeek::run_state::network_time, killed_by_inactivity)); + file->Write(util::fmt("%.06f Connections expired due to inactivity: %" PRIu64 "\n", + run_state::network_time, killed_by_inactivity)); - file->Write(zeek::util::fmt("%.06f Total reassembler data: %" PRIu64 "K\n", zeek::run_state::network_time, - Reassembler::TotalMemoryAllocation() / 1024)); + file->Write(util::fmt("%.06f Total reassembler data: %" PRIu64 "K\n", run_state::network_time, + Reassembler::TotalMemoryAllocation() / 1024)); // Signature engine. - if ( expensive && zeek::detail::rule_matcher ) + if ( expensive && rule_matcher ) { - zeek::detail::RuleMatcher::Stats stats; - zeek::detail::rule_matcher->GetStats(&stats); + RuleMatcher::Stats stats; + rule_matcher->GetStats(&stats); - file->Write(zeek::util::fmt("%06f RuleMatcher: matchers=%d nfa_states=%d dfa_states=%d " - "ncomputed=%d mem=%dK\n", zeek::run_state::network_time, stats.matchers, - stats.nfa_states, stats.dfa_states, stats.computed, stats.mem / 1024)); + file->Write(util::fmt("%06f RuleMatcher: matchers=%d nfa_states=%d dfa_states=%d " + "ncomputed=%d mem=%dK\n", run_state::network_time, stats.matchers, + stats.nfa_states, stats.dfa_states, stats.computed, stats.mem / 1024)); } - file->Write(zeek::util::fmt("%.06f Timers: current=%d max=%d lag=%.2fs\n", - zeek::run_state::network_time, - zeek::detail::timer_mgr->Size(), zeek::detail::timer_mgr->PeakSize(), - zeek::run_state::network_time - zeek::detail::timer_mgr->LastTimestamp())); + file->Write(util::fmt("%.06f Timers: current=%d max=%d lag=%.2fs\n", + run_state::network_time, + timer_mgr->Size(), timer_mgr->PeakSize(), + run_state::network_time - timer_mgr->LastTimestamp())); - zeek::detail::DNS_Mgr::Stats dstats; - zeek::detail::dns_mgr->GetStats(&dstats); + DNS_Mgr::Stats dstats; + dns_mgr->GetStats(&dstats); - file->Write(zeek::util::fmt("%.06f DNS_Mgr: requests=%lu succesful=%lu failed=%lu pending=%lu cached_hosts=%lu cached_addrs=%lu\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.06f DNS_Mgr: requests=%lu succesful=%lu failed=%lu pending=%lu cached_hosts=%lu cached_addrs=%lu\n", + run_state::network_time, dstats.requests, dstats.successful, dstats.failed, dstats.pending, dstats.cached_hosts, dstats.cached_addresses)); - zeek::detail::trigger::Manager::Stats tstats; - zeek::detail::trigger_mgr->GetStats(&tstats); + trigger::Manager::Stats tstats; + trigger_mgr->GetStats(&tstats); - file->Write(zeek::util::fmt("%.06f Triggers: total=%lu pending=%lu\n", zeek::run_state::network_time, tstats.total, tstats.pending)); + file->Write(util::fmt("%.06f Triggers: total=%lu pending=%lu\n", run_state::network_time, tstats.total, tstats.pending)); - unsigned int* current_timers = zeek::detail::TimerMgr::CurrentTimers(); - for ( int i = 0; i < zeek::detail::NUM_TIMER_TYPES; ++i ) + unsigned int* current_timers = TimerMgr::CurrentTimers(); + for ( int i = 0; i < NUM_TIMER_TYPES; ++i ) { if ( current_timers[i] ) - file->Write(zeek::util::fmt("%.06f %s = %d\n", zeek::run_state::network_time, - zeek::detail::timer_type_to_string(static_cast(i)), + file->Write(util::fmt("%.06f %s = %d\n", run_state::network_time, + timer_type_to_string(static_cast(i)), current_timers[i])); } - file->Write(zeek::util::fmt("%0.6f Threads: current=%d\n", zeek::run_state::network_time, zeek::thread_mgr->NumThreads())); + file->Write(util::fmt("%0.6f Threads: current=%d\n", run_state::network_time, thread_mgr->NumThreads())); - const threading::Manager::msg_stats_list& thread_stats = zeek::thread_mgr->GetMsgThreadStats(); + const threading::Manager::msg_stats_list& thread_stats = thread_mgr->GetMsgThreadStats(); for ( threading::Manager::msg_stats_list::const_iterator i = thread_stats.begin(); i != thread_stats.end(); ++i ) { threading::MsgThread::Stats s = i->second; - file->Write(zeek::util::fmt("%0.6f %-25s in=%" PRIu64 " out=%" PRIu64 " pending=%" PRIu64 "/%" PRIu64 + file->Write(util::fmt("%0.6f %-25s in=%" PRIu64 " out=%" PRIu64 " pending=%" PRIu64 "/%" PRIu64 " (#queue r/w: in=%" PRIu64 "/%" PRIu64 " out=%" PRIu64 "/%" PRIu64 ")" "\n", - zeek::run_state::network_time, + run_state::network_time, i->first.c_str(), s.sent_in, s.sent_out, s.pending_in, s.pending_out, @@ -232,12 +232,12 @@ void ProfileLogger::Log() auto cs = broker_mgr->GetStatistics(); - file->Write(zeek::util::fmt("%0.6f Comm: peers=%zu stores=%zu " + file->Write(util::fmt("%0.6f Comm: peers=%zu stores=%zu " "pending_queries=%zu " "events_in=%zu events_out=%zu " "logs_in=%zu logs_out=%zu " "ids_in=%zu ids_out=%zu ", - zeek::run_state::network_time, cs.num_peers, cs.num_stores, + run_state::network_time, cs.num_peers, cs.num_stores, cs.num_pending_queries, cs.num_events_incoming, cs.num_events_outgoing, cs.num_logs_incoming, cs.num_logs_outgoing, @@ -246,15 +246,15 @@ void ProfileLogger::Log() // Script-level state. unsigned int size, mem = 0; - const auto& globals = zeek::detail::global_scope()->Vars(); + const auto& globals = global_scope()->Vars(); if ( expensive ) { int total_table_entries = 0; int total_table_rentries = 0; - file->Write(zeek::util::fmt("%.06f Global_sizes > 100k: %dK\n", - zeek::run_state::network_time, mem / 1024)); + file->Write(util::fmt("%.06f Global_sizes > 100k: %dK\n", + run_state::network_time, mem / 1024)); for ( const auto& global : globals ) { @@ -276,7 +276,7 @@ void ProfileLogger::Log() if ( size > 100 * 1024 ) print = true; - if ( v->GetType()->Tag() == zeek::TYPE_TABLE ) + if ( v->GetType()->Tag() == TYPE_TABLE ) { entries = v->AsTable()->Length(); total_table_entries += entries; @@ -294,12 +294,12 @@ void ProfileLogger::Log() if ( print ) { - file->Write(zeek::util::fmt("%.06f %s = %dK", - zeek::run_state::network_time, id->Name(), + file->Write(util::fmt("%.06f %s = %dK", + run_state::network_time, id->Name(), size / 1024)); if ( entries >= 0 ) - file->Write(zeek::util::fmt(" (%d/%d entries)\n", + file->Write(util::fmt(" (%d/%d entries)\n", entries, rentries)); else file->Write("\n"); @@ -307,10 +307,10 @@ void ProfileLogger::Log() } } - file->Write(zeek::util::fmt("%.06f Global_sizes total: %dK\n", - zeek::run_state::network_time, mem / 1024)); - file->Write(zeek::util::fmt("%.06f Total number of table entries: %d/%d\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.06f Global_sizes total: %dK\n", + run_state::network_time, mem / 1024)); + file->Write(util::fmt("%.06f Total number of table entries: %d/%d\n", + run_state::network_time, total_table_entries, total_table_rentries)); } @@ -318,39 +318,39 @@ void ProfileLogger::Log() // (and for consistency we dispatch it *now*) if ( profiling_update ) { - zeek::event_mgr.Dispatch(new zeek::Event(profiling_update, { - zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, file}), - zeek::val_mgr->Bool(expensive), + event_mgr.Dispatch(new Event(profiling_update, { + make_intrusive(IntrusivePtr{NewRef{}, file}), + val_mgr->Bool(expensive), })); } } -void ProfileLogger::SegmentProfile(const char* name, const zeek::detail::Location* loc, +void ProfileLogger::SegmentProfile(const char* name, const Location* loc, double dtime, int dmem) { if ( name ) - file->Write(zeek::util::fmt("%.06f segment-%s dt=%.06f dmem=%d\n", - zeek::run_state::network_time, name, dtime, dmem)); + file->Write(util::fmt("%.06f segment-%s dt=%.06f dmem=%d\n", + run_state::network_time, name, dtime, dmem)); else if ( loc ) - file->Write(zeek::util::fmt("%.06f segment-%s:%d dt=%.06f dmem=%d\n", - zeek::run_state::network_time, + file->Write(util::fmt("%.06f segment-%s:%d dt=%.06f dmem=%d\n", + run_state::network_time, loc->filename ? loc->filename : "nofile", loc->first_line, dtime, dmem)); else - file->Write(zeek::util::fmt("%.06f segment-XXX dt=%.06f dmem=%d\n", - zeek::run_state::network_time, dtime, dmem)); + file->Write(util::fmt("%.06f segment-XXX dt=%.06f dmem=%d\n", + run_state::network_time, dtime, dmem)); } SampleLogger::SampleLogger() { - static zeek::TableType* load_sample_info = nullptr; + static TableType* load_sample_info = nullptr; if ( ! load_sample_info ) - load_sample_info = zeek::id::find_type("load_sample_info")->AsTableType(); + load_sample_info = id::find_type("load_sample_info")->AsTableType(); - load_samples = new zeek::TableVal({zeek::NewRef{}, load_sample_info}); + load_samples = new TableVal({NewRef{}, load_sample_info}); } SampleLogger::~SampleLogger() @@ -358,27 +358,27 @@ SampleLogger::~SampleLogger() Unref(load_samples); } -void SampleLogger::FunctionSeen(const zeek::Func* func) +void SampleLogger::FunctionSeen(const Func* func) { - auto idx = zeek::make_intrusive(func->Name()); + auto idx = make_intrusive(func->Name()); load_samples->Assign(std::move(idx), nullptr); } -void SampleLogger::LocationSeen(const zeek::detail::Location* loc) +void SampleLogger::LocationSeen(const Location* loc) { - auto idx = zeek::make_intrusive(loc->filename); + auto idx = make_intrusive(loc->filename); load_samples->Assign(std::move(idx), nullptr); } void SampleLogger::SegmentProfile(const char* /* name */, - const zeek::detail::Location* /* loc */, + const Location* /* loc */, double dtime, int dmem) { if ( load_sample ) - zeek::event_mgr.Enqueue(load_sample, - zeek::IntrusivePtr{zeek::NewRef{}, load_samples}, - zeek::make_intrusive(dtime, Seconds), - zeek::val_mgr->Int(dmem) + event_mgr.Enqueue(load_sample, + IntrusivePtr{NewRef{}, load_samples}, + make_intrusive(dtime, Seconds), + val_mgr->Int(dmem) ); } @@ -414,7 +414,7 @@ void SegmentProfiler::Report() } PacketProfiler::PacketProfiler(unsigned int mode, double freq, - zeek::File* arg_file) + File* arg_file) { update_mode = mode; update_freq = freq; @@ -442,7 +442,7 @@ void PacketProfiler::ProfilePkt(double t, unsigned int bytes) getrusage(RUSAGE_SELF, &res); gettimeofday(&ptimestamp, 0); - zeek::util::get_memory_usage(&last_mem, nullptr); + util::get_memory_usage(&last_mem, nullptr); last_Utime = res.ru_utime.tv_sec + res.ru_utime.tv_usec / 1e6; last_Stime = res.ru_stime.tv_sec + res.ru_stime.tv_usec / 1e6; last_Rtime = ptimestamp.tv_sec + ptimestamp.tv_usec / 1e6; @@ -466,9 +466,9 @@ void PacketProfiler::ProfilePkt(double t, unsigned int bytes) ptimestamp.tv_sec + ptimestamp.tv_usec / 1e6; uint64_t curr_mem; - zeek::util::get_memory_usage(&curr_mem, nullptr); + util::get_memory_usage(&curr_mem, nullptr); - file->Write(zeek::util::fmt("%.06f %.03f %" PRIu64 " %" PRIu64 " %.03f %.03f %.03f %" PRIu64 "\n", + file->Write(util::fmt("%.06f %.03f %" PRIu64 " %" PRIu64 " %.03f %.03f %.03f %" PRIu64 "\n", t, time-last_timestamp, pkt_cnt, byte_cnt, curr_Rtime - last_Rtime, curr_Utime - last_Utime, diff --git a/src/Stats.h b/src/Stats.h index 85e22a19e4..cc971af47c 100644 --- a/src/Stats.h +++ b/src/Stats.h @@ -25,8 +25,8 @@ public: SegmentStatsReporter() { } virtual ~SegmentStatsReporter() { } - virtual void SegmentProfile(const char* name, const zeek::detail::Location* loc, - double dtime, int dmem) = 0; + virtual void SegmentProfile(const char* name, const Location* loc, + double dtime, int dmem) = 0; }; @@ -47,7 +47,7 @@ public: } SegmentProfiler(SegmentStatsReporter* arg_reporter, - const zeek::detail::Location* arg_loc) + const Location* arg_loc) : reporter(arg_reporter), name(), loc(arg_loc), initial_rusage() { if ( reporter ) @@ -66,7 +66,7 @@ protected: SegmentStatsReporter* reporter; const char* name; - const zeek::detail::Location* loc; + const Location* loc; struct rusage initial_rusage; }; @@ -80,7 +80,7 @@ public: zeek::File* File() { return file; } protected: - void SegmentProfile(const char* name, const zeek::detail::Location* loc, + void SegmentProfile(const char* name, const Location* loc, double dtime, int dmem) override; private: @@ -97,14 +97,14 @@ public: // These are called to report that a given function or location // has been seen during the sampling. - void FunctionSeen(const zeek::Func* func); - void LocationSeen(const zeek::detail::Location* loc); + void FunctionSeen(const Func* func); + void LocationSeen(const Location* loc); protected: - void SegmentProfile(const char* name, const zeek::detail::Location* loc, + void SegmentProfile(const char* name, const Location* loc, double dtime, int dmem) override; - zeek::TableVal* load_samples; + TableVal* load_samples; }; @@ -123,7 +123,7 @@ extern uint64_t tot_gap_bytes; class PacketProfiler { public: - PacketProfiler(unsigned int mode, double freq, zeek::File* arg_file); + PacketProfiler(unsigned int mode, double freq, File* arg_file); ~PacketProfiler(); static const unsigned int MODE_TIME = 1; @@ -133,7 +133,7 @@ public: void ProfilePkt(double t, unsigned int bytes); protected: - zeek::File* file; + File* file; unsigned int update_mode; double update_freq; double last_Utime, last_Stime, last_Rtime; diff --git a/src/Stmt.cc b/src/Stmt.cc index 37d162b3c6..fe6bb431a5 100644 --- a/src/Stmt.cc +++ b/src/Stmt.cc @@ -120,7 +120,7 @@ void Stmt::DecrBPCount() if ( breakpoint_count ) --breakpoint_count; else - zeek::reporter->InternalError("breakpoint count decremented below 0"); + reporter->InternalError("breakpoint count decremented below 0"); } void Stmt::AddTag(ODesc* d) const @@ -143,7 +143,7 @@ void Stmt::AccessStats(ODesc* d) const if ( d->IncludeStats() ) { d->Add("(@"); - d->Add(last_access ? zeek::util::detail::fmt_access_time(last_access) : ""); + d->Add(last_access ? util::detail::fmt_access_time(last_access) : ""); d->Add(" #"); d->Add(access_count); d->Add(")"); @@ -169,7 +169,7 @@ ExprListStmt::~ExprListStmt() = default; ValPtr ExprListStmt::Exec(Frame* f, StmtFlowType& flow) const { - last_access = zeek::run_state::network_time; + last_access = run_state::network_time; flow = FLOW_NEXT; auto vals = eval_list(f, l.get()); @@ -203,7 +203,7 @@ TraversalCode ExprListStmt::Traverse(TraversalCallback* cb) const HANDLE_TC_STMT_POST(tc); } -static zeek::File* print_stdout = nullptr; +static File* print_stdout = nullptr; static EnumValPtr lookup_enum_val(const char* module_name, const char* name) { @@ -222,20 +222,20 @@ static EnumValPtr lookup_enum_val(const char* module_name, const char* name) static void print_log(const std::vector& vals) { static auto plval = lookup_enum_val("Log", "PRINTLOG"); - static auto lpli = zeek::id::find_type("Log::PrintLogInfo"); - auto record = zeek::make_intrusive(lpli); - auto vec = zeek::make_intrusive(zeek::id::string_vec); + static auto lpli = id::find_type("Log::PrintLogInfo"); + auto record = make_intrusive(lpli); + auto vec = make_intrusive(id::string_vec); for ( const auto& val : vals ) { ODesc d(DESC_READABLE); val->Describe(&d); - vec->Assign(vec->Size(), zeek::make_intrusive(d.Description())); + vec->Assign(vec->Size(), make_intrusive(d.Description())); } - record->Assign(0, zeek::make_intrusive(zeek::run_state::network_time)); + record->Assign(0, make_intrusive(run_state::network_time)); record->Assign(1, std::move(vec)); - zeek::log_mgr->Write(plval.get(), record.get()); + log_mgr->Write(plval.get(), record.get()); } ValPtr PrintStmt::DoExec(std::vector vals, @@ -244,9 +244,9 @@ ValPtr PrintStmt::DoExec(std::vector vals, RegisterAccess(); if ( ! print_stdout ) - print_stdout = new zeek::File(stdout); + print_stdout = new File(stdout); - zeek::File* f = print_stdout; + File* f = print_stdout; int offset = 0; if ( vals.size() > 0 && (vals)[0]->GetType()->Tag() == TYPE_FILE ) @@ -259,7 +259,7 @@ ValPtr PrintStmt::DoExec(std::vector vals, } static auto print_log_type = static_cast( - zeek::id::find_val("Log::print_to_log")->AsEnum()); + id::find_val("Log::print_to_log")->AsEnum()); switch ( print_log_type ) { case BifEnum::Log::REDIRECT_NONE: @@ -279,12 +279,12 @@ ValPtr PrintStmt::DoExec(std::vector vals, } break; default: - zeek::reporter->InternalError("unknown Log::PrintLogType value: %d", - print_log_type); + reporter->InternalError("unknown Log::PrintLogType value: %d", + print_log_type); break; } - desc_style style = f->IsRawOutput() ? RAW_STYLE : STANDARD_STYLE; + DescStyle style = f->IsRawOutput() ? RAW_STYLE : STANDARD_STYLE; if ( f->IsRawOutput() ) { @@ -602,7 +602,7 @@ static void int_del_func(void* v) void SwitchStmt::Init() { - auto t = zeek::make_intrusive(); + auto t = make_intrusive(); t->Append(e->GetType()); comp_hash = new CompositeHash(std::move(t)); @@ -745,10 +745,10 @@ bool SwitchStmt::AddCaseLabelValueMapping(const Val* v, int idx) if ( ! hk ) { - zeek::reporter->PushLocation(e->GetLocationInfo()); - zeek::reporter->InternalError("switch expression type mismatch (%s/%s)", - type_name(v->GetType()->Tag()), - type_name(e->GetType()->Tag())); + reporter->PushLocation(e->GetLocationInfo()); + reporter->InternalError("switch expression type mismatch (%s/%s)", + type_name(v->GetType()->Tag()), + type_name(e->GetType()->Tag())); } int* label_idx = case_label_value_map.Lookup(hk.get()); @@ -786,10 +786,10 @@ std::pair SwitchStmt::FindCaseLabelMatch(const Val* v) const if ( ! hk ) { - zeek::reporter->PushLocation(e->GetLocationInfo()); - zeek::reporter->Error("switch expression type mismatch (%s/%s)", - type_name(v->GetType()->Tag()), - type_name(e->GetType()->Tag())); + reporter->PushLocation(e->GetLocationInfo()); + reporter->Error("switch expression type mismatch (%s/%s)", + type_name(v->GetType()->Tag()), + type_name(e->GetType()->Tag())); return std::make_pair(-1, nullptr); } @@ -982,7 +982,7 @@ ValPtr EventStmt::Exec(Frame* f, StmtFlowType& flow) const auto h = event_expr->Handler(); if ( args && h ) - zeek::event_mgr.Enqueue(h, std::move(*args)); + event_mgr.Enqueue(h, std::move(*args)); flow = FLOW_NEXT; return nullptr; @@ -1111,7 +1111,7 @@ ForStmt::ForStmt(IDPList* arg_loop_vars, ExprPtr loop_expr) else { - add_local({zeek::NewRef{}, lv}, ind_type, INIT_NONE, + add_local({NewRef{}, lv}, ind_type, INIT_NONE, nullptr, nullptr, VAR_REGULAR); } } @@ -1128,7 +1128,7 @@ ForStmt::ForStmt(IDPList* arg_loop_vars, ExprPtr loop_expr) const auto& t = (*loop_vars)[0]->GetType(); if ( ! t ) - add_local({zeek::NewRef{}, (*loop_vars)[0]}, base_type(TYPE_COUNT), + add_local({NewRef{}, (*loop_vars)[0]}, base_type(TYPE_COUNT), INIT_NONE, nullptr, nullptr, VAR_REGULAR); else if ( ! IsIntegral(t->Tag()) ) @@ -1149,7 +1149,7 @@ ForStmt::ForStmt(IDPList* arg_loop_vars, ExprPtr loop_expr) const auto& t = (*loop_vars)[0]->GetType(); if ( ! t ) - add_local({zeek::NewRef{}, (*loop_vars)[0]}, + add_local({NewRef{}, (*loop_vars)[0]}, base_type(TYPE_STRING), INIT_NONE, nullptr, nullptr, VAR_REGULAR); @@ -1202,7 +1202,7 @@ ValPtr ForStmt::DoExec(Frame* f, Val* v, StmtFlowType& flow) const if ( v->GetType()->Tag() == TYPE_TABLE ) { TableVal* tv = v->AsTableVal(); - const PDict* loop_vals = tv->AsTable(); + const PDict* loop_vals = tv->AsTable(); if ( ! loop_vals->Length() ) return nullptr; @@ -1255,7 +1255,7 @@ ValPtr ForStmt::DoExec(Frame* f, Val* v, StmtFlowType& flow) const // Set the loop variable to the current index, and make // another pass over the loop body. - f->SetElement((*loop_vars)[0], zeek::val_mgr->Count(i)); + f->SetElement((*loop_vars)[0], val_mgr->Count(i)); flow = FLOW_NEXT; ret = body->Exec(f, flow); @@ -1269,7 +1269,7 @@ ValPtr ForStmt::DoExec(Frame* f, Val* v, StmtFlowType& flow) const for ( int i = 0; i < sval->Len(); ++i ) { - auto sv = zeek::make_intrusive(1, (const char*) sval->Bytes() + i); + auto sv = make_intrusive(1, (const char*) sval->Bytes() + i); f->SetElement((*loop_vars)[0], std::move(sv)); flow = FLOW_NEXT; ret = body->Exec(f, flow); @@ -1675,14 +1675,14 @@ ValPtr InitStmt::Exec(Frame* f, StmtFlowType& flow) const switch ( t->Tag() ) { case TYPE_RECORD: - v = zeek::make_intrusive(zeek::cast_intrusive(t)); + v = make_intrusive(cast_intrusive(t)); break; case TYPE_VECTOR: - v = zeek::make_intrusive(zeek::cast_intrusive(t)); + v = make_intrusive(cast_intrusive(t)); break; case TYPE_TABLE: - v = zeek::make_intrusive(zeek::cast_intrusive(t), - aggr->GetAttrs()); + v = make_intrusive(cast_intrusive(t), + aggr->GetAttrs()); break; default: break; @@ -1859,4 +1859,4 @@ TraversalCode WhenStmt::Traverse(TraversalCallback* cb) const HANDLE_TC_STMT_POST(tc); } -} +} // namespace zeek::detail diff --git a/src/Stmt.h b/src/Stmt.h index 10cfa22856..e00e645b6f 100644 --- a/src/Stmt.h +++ b/src/Stmt.h @@ -25,11 +25,11 @@ class ForStmt; class EventExpr; class ListExpr; -using EventExprPtr = zeek::IntrusivePtr; -using ListExprPtr = zeek::IntrusivePtr; +using EventExprPtr = IntrusivePtr; +using ListExprPtr = IntrusivePtr; class Stmt; -using StmtPtr = zeek::IntrusivePtr; +using StmtPtr = IntrusivePtr; class Stmt : public Obj { public: @@ -53,7 +53,7 @@ public: ForStmt* AsForStmt(); - void RegisterAccess() const { last_access = zeek::run_state::network_time; access_count++; } + void RegisterAccess() const { last_access = run_state::network_time; access_count++; } void AccessStats(ODesc* d) const; uint32_t GetAccessCount() const { return access_count; } @@ -177,7 +177,7 @@ protected: StmtPtr s; }; -using case_list = zeek::PList; +using case_list = PList; class SwitchStmt final : public ExprStmt { public: @@ -216,7 +216,7 @@ protected: case_list* cases; int default_case_idx; CompositeHash* comp_hash; - zeek::PDict case_label_value_map; + PDict case_label_value_map; std::vector> case_label_type_list; }; diff --git a/src/Tag.cc b/src/Tag.cc index a3741eac84..9878a903f5 100644 --- a/src/Tag.cc +++ b/src/Tag.cc @@ -5,7 +5,7 @@ namespace zeek { -Tag::Tag(const zeek::EnumTypePtr& etype, type_t arg_type, subtype_t arg_subtype) +Tag::Tag(const EnumTypePtr& etype, type_t arg_type, subtype_t arg_subtype) { assert(arg_type > 0); @@ -15,11 +15,11 @@ Tag::Tag(const zeek::EnumTypePtr& etype, type_t arg_type, subtype_t arg_subtype) val = etype->GetEnumVal(i); } -Tag::Tag(zeek::EnumType* etype, type_t arg_type, subtype_t arg_subtype) - : Tag({zeek::NewRef{}, etype}, arg_type, arg_subtype) +Tag::Tag(EnumType* etype, type_t arg_type, subtype_t arg_subtype) + : Tag({NewRef{}, etype}, arg_type, arg_subtype) { } -Tag::Tag(zeek::EnumValPtr arg_val) +Tag::Tag(EnumValPtr arg_val) { assert(arg_val); @@ -30,8 +30,8 @@ Tag::Tag(zeek::EnumValPtr arg_val) subtype = (i >> 31) & 0xffffffff; } -Tag::Tag(zeek::EnumVal* arg_val) - : Tag({zeek::NewRef{}, arg_val}) +Tag::Tag(EnumVal* arg_val) + : Tag({NewRef{}, arg_val}) { } Tag::Tag(const Tag& other) @@ -74,7 +74,7 @@ Tag& Tag::operator=(const Tag&& other) noexcept return *this; } -const zeek::EnumValPtr& Tag::AsVal(const zeek::EnumTypePtr& etype) const +const EnumValPtr& Tag::AsVal(const EnumTypePtr& etype) const { if ( ! val ) { @@ -85,14 +85,14 @@ const zeek::EnumValPtr& Tag::AsVal(const zeek::EnumTypePtr& etype) const return val; } -zeek::EnumVal* Tag::AsEnumVal(zeek::EnumType* etype) const +EnumVal* Tag::AsEnumVal(EnumType* etype) const { - return AsVal({zeek::NewRef{}, etype}).get(); + return AsVal({NewRef{}, etype}).get(); } std::string Tag::AsString() const { - return zeek::util::fmt("%" PRIu32 "/%" PRIu32, type, subtype); + return util::fmt("%" PRIu32 "/%" PRIu32, type, subtype); } } // namespace zeek diff --git a/src/Tag.h b/src/Tag.h index 52030f7d10..a7b856eeff 100644 --- a/src/Tag.h +++ b/src/Tag.h @@ -15,8 +15,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek); namespace zeek { -using EnumTypePtr = zeek::IntrusivePtr; -using EnumValPtr = zeek::IntrusivePtr; +using EnumTypePtr = IntrusivePtr; +using EnumValPtr = IntrusivePtr; /** * Class to identify an analyzer type. @@ -121,10 +121,10 @@ protected: * * @param etype the script-layer enum type associated with the tag. */ - const zeek::EnumValPtr& AsVal(const zeek::EnumTypePtr& etype) const; + const EnumValPtr& AsVal(const EnumTypePtr& etype) const; [[deprecated("Remove in v4.1. Use AsVal() instead.")]] - zeek::EnumVal* AsEnumVal(zeek::EnumType* etype) const; + EnumVal* AsEnumVal(EnumType* etype) const; /** * Constructor. @@ -137,25 +137,25 @@ protected: * @param subtype The sub type, which is left to an analyzer for * interpretation. By default it's set to zero. */ - Tag(const zeek::EnumTypePtr& etype, type_t type, subtype_t subtype = 0); + Tag(const EnumTypePtr& etype, type_t type, subtype_t subtype = 0); - [[deprecated("Remove in v4.1. Construct from zeek::IntrusivePtr& instead.")]] - Tag(zeek::EnumType* etype, type_t type, subtype_t subtype = 0); + [[deprecated("Remove in v4.1. Construct from IntrusivePtr& instead.")]] + Tag(EnumType* etype, type_t type, subtype_t subtype = 0); /** * Constructor. * * @param val An enum value of script type \c Analyzer::Tag. */ - explicit Tag(zeek::EnumValPtr val); + explicit Tag(EnumValPtr val); - [[deprecated("Remove in v4.1. Construct from zeek::IntrusivePtr instead.")]] - explicit Tag(zeek::EnumVal* val); + [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] + explicit Tag(EnumVal* val); private: type_t type; // Main type. subtype_t subtype; // Subtype. - mutable zeek::EnumValPtr val; // Script-layer value. + mutable EnumValPtr val; // Script-layer value. }; } // namespace zeek diff --git a/src/Timer.cc b/src/Timer.cc index 48722c0f54..85e0024da8 100644 --- a/src/Timer.cc +++ b/src/Timer.cc @@ -69,8 +69,8 @@ TimerMgr::TimerMgr() num_expired = 0; last_advance = last_timestamp = 0; - if ( zeek::iosource_mgr ) - zeek::iosource_mgr->Register(this, true); + if ( iosource_mgr ) + iosource_mgr->Register(this, true); } TimerMgr::~TimerMgr() @@ -79,7 +79,7 @@ TimerMgr::~TimerMgr() int TimerMgr::Advance(double arg_t, int max_expire) { - DBG_LOG(zeek::DBG_TM, "advancing timer mgr to %.6f", arg_t); + DBG_LOG(DBG_TM, "advancing timer mgr to %.6f", arg_t); t = arg_t; last_timestamp = 0; @@ -95,20 +95,20 @@ void TimerMgr::Process() // If we don't have a source, or the source is closed, or we're reading live (which includes // pseudo-realtime), advance the timer here to the current time since otherwise it won't // move forward and the timers won't fire correctly. - iosource::PktSrc* pkt_src = zeek::iosource_mgr->GetPktSrc(); - if ( ! pkt_src || ! pkt_src->IsOpen() || zeek::run_state::reading_live || zeek::run_state::is_processing_suspended() ) - zeek::run_state::detail::update_network_time(zeek::util::current_time()); + iosource::PktSrc* pkt_src = iosource_mgr->GetPktSrc(); + if ( ! pkt_src || ! pkt_src->IsOpen() || run_state::reading_live || run_state::is_processing_suspended() ) + run_state::detail::update_network_time(util::current_time()); // Just advance the timer manager based on the current network time. This won't actually // change the time, but will dispatch any timers that need dispatching. - zeek::run_state::current_dispatched += Advance( - zeek::run_state::network_time, max_timer_expires - zeek::run_state::current_dispatched); + run_state::current_dispatched += Advance( + run_state::network_time, max_timer_expires - run_state::current_dispatched); } void TimerMgr::InitPostScript() { - if ( zeek::iosource_mgr ) - zeek::iosource_mgr->Register(this, true); + if ( iosource_mgr ) + iosource_mgr->Register(this, true); } PQ_TimerMgr::PQ_TimerMgr() : TimerMgr() @@ -123,14 +123,14 @@ PQ_TimerMgr::~PQ_TimerMgr() void PQ_TimerMgr::Add(Timer* timer) { - DBG_LOG(zeek::DBG_TM, "Adding timer %s (%p) at %.6f", + DBG_LOG(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 // multiple already-added timers are added, they'll still // execute in sorted order. if ( ! q->Add(timer) ) - zeek::reporter->InternalError("out of memory"); + reporter->InternalError("out of memory"); ++current_timers[timer->Type()]; } @@ -140,7 +140,7 @@ void PQ_TimerMgr::Expire() Timer* timer; while ( (timer = Remove()) ) { - DBG_LOG(zeek::DBG_TM, "Dispatching timer %s (%p)", + DBG_LOG(DBG_TM, "Dispatching timer %s (%p)", timer_type_to_string(timer->Type()), timer); timer->Dispatch(t, true); --current_timers[timer->Type()]; @@ -162,7 +162,7 @@ int PQ_TimerMgr::DoAdvance(double new_t, int max_expire) // whether we should delete it too. (void) Remove(); - DBG_LOG(zeek::DBG_TM, "Dispatching timer %s (%p)", + DBG_LOG(DBG_TM, "Dispatching timer %s (%p)", timer_type_to_string(timer->Type()), timer); timer->Dispatch(new_t, false); delete timer; @@ -176,7 +176,7 @@ int PQ_TimerMgr::DoAdvance(double new_t, int max_expire) void PQ_TimerMgr::Remove(Timer* timer) { if ( ! q->Remove(timer) ) - zeek::reporter->InternalError("asked to remove a missing timer"); + reporter->InternalError("asked to remove a missing timer"); --current_timers[timer->Type()]; delete timer; @@ -186,7 +186,7 @@ double PQ_TimerMgr::GetNextTimeout() { Timer* top = Top(); if ( top ) - return std::max(0.0, top->Time() - zeek::run_state::network_time); + return std::max(0.0, top->Time() - run_state::network_time); return -1; } diff --git a/src/Timer.h b/src/Timer.h index 433063ece4..e397f37f93 100644 --- a/src/Timer.h +++ b/src/Timer.h @@ -50,9 +50,9 @@ constexpr int NUM_TIMER_TYPES = int(TIMER_THREAD_HEARTBEAT) + 1; extern const char* timer_type_to_string(TimerType type); -class Timer : public zeek::detail::PQ_Element { +class Timer : public PQ_Element { public: - Timer(double t, TimerType arg_type) : zeek::detail::PQ_Element(t), type(arg_type) {} + Timer(double t, TimerType arg_type) : PQ_Element(t), type(arg_type) {} ~Timer() override { } TimerType Type() const { return type; } @@ -167,7 +167,7 @@ protected: Timer* Remove() { return (Timer*) q->Remove(); } Timer* Top() { return (Timer*) q->Top(); } - zeek::detail::PriorityQueue* q; + PriorityQueue* q; }; extern TimerMgr* timer_mgr; diff --git a/src/Traverse.cc b/src/Traverse.cc index fcaaaf10bb..b7c8b2592e 100644 --- a/src/Traverse.cc +++ b/src/Traverse.cc @@ -9,16 +9,16 @@ namespace zeek::detail { TraversalCode traverse_all(TraversalCallback* cb) { - if ( ! zeek::detail::global_scope() ) + if ( ! global_scope() ) return TC_CONTINUE; if ( ! stmts ) // May be null when parsing fails. return TC_CONTINUE; - cb->current_scope = zeek::detail::global_scope(); + cb->current_scope = global_scope(); - TraversalCode tc = zeek::detail::global_scope()->Traverse(cb); + TraversalCode tc = global_scope()->Traverse(cb); HANDLE_TC_STMT_PRE(tc); tc = stmts->Traverse(cb); diff --git a/src/Traverse.h b/src/Traverse.h index 47406319eb..0cba88aa8e 100644 --- a/src/Traverse.h +++ b/src/Traverse.h @@ -17,25 +17,25 @@ public: TraversalCallback() { current_scope = nullptr; } virtual ~TraversalCallback() {} - virtual TraversalCode PreFunction(const zeek::Func*) { return TC_CONTINUE; } - virtual TraversalCode PostFunction(const zeek::Func*) { return TC_CONTINUE; } + virtual TraversalCode PreFunction(const Func*) { return TC_CONTINUE; } + virtual TraversalCode PostFunction(const Func*) { return TC_CONTINUE; } - virtual TraversalCode PreStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; } - virtual TraversalCode PostStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; } + virtual TraversalCode PreStmt(const Stmt*) { return TC_CONTINUE; } + virtual TraversalCode PostStmt(const Stmt*) { return TC_CONTINUE; } - virtual TraversalCode PreExpr(const zeek::detail::Expr*) { return TC_CONTINUE; } - virtual TraversalCode PostExpr(const zeek::detail::Expr*) { return TC_CONTINUE; } + virtual TraversalCode PreExpr(const Expr*) { return TC_CONTINUE; } + virtual TraversalCode PostExpr(const Expr*) { return TC_CONTINUE; } - virtual TraversalCode PreID(const zeek::detail::ID*) { return TC_CONTINUE; } - virtual TraversalCode PostID(const zeek::detail::ID*) { return TC_CONTINUE; } + virtual TraversalCode PreID(const ID*) { return TC_CONTINUE; } + virtual TraversalCode PostID(const ID*) { return TC_CONTINUE; } - virtual TraversalCode PreTypedef(const zeek::detail::ID*) { return TC_CONTINUE; } - virtual TraversalCode PostTypedef(const zeek::detail::ID*) { return TC_CONTINUE; } + virtual TraversalCode PreTypedef(const ID*) { return TC_CONTINUE; } + virtual TraversalCode PostTypedef(const ID*) { return TC_CONTINUE; } - virtual TraversalCode PreDecl(const zeek::detail::ID*) { return TC_CONTINUE; } - virtual TraversalCode PostDecl(const zeek::detail::ID*) { return TC_CONTINUE; } + virtual TraversalCode PreDecl(const ID*) { return TC_CONTINUE; } + virtual TraversalCode PostDecl(const ID*) { return TC_CONTINUE; } - zeek::detail::Scope* current_scope; + Scope* current_scope; }; TraversalCode traverse_all(TraversalCallback* cb); diff --git a/src/Trigger.cc b/src/Trigger.cc index 3e03810a01..6a1820a40a 100644 --- a/src/Trigger.cc +++ b/src/Trigger.cc @@ -31,13 +31,13 @@ public: ~TriggerTraversalCallback() { Unref(trigger); } - virtual TraversalCode PreExpr(const zeek::detail::Expr*) override; + virtual TraversalCode PreExpr(const Expr*) override; private: Trigger* trigger; }; -TraversalCode zeek::detail::trigger::TriggerTraversalCallback::PreExpr(const zeek::detail::Expr* expr) +TraversalCode trigger::TriggerTraversalCallback::PreExpr(const Expr* expr) { // We catch all expressions here which in some way reference global // state. @@ -45,7 +45,7 @@ TraversalCode zeek::detail::trigger::TriggerTraversalCallback::PreExpr(const zee switch ( expr->Tag() ) { case EXPR_NAME: { - const auto* e = static_cast(expr); + const auto* e = static_cast(expr); if ( e->Id()->IsGlobal() ) trigger->Register(e->Id()); @@ -58,7 +58,7 @@ TraversalCode zeek::detail::trigger::TriggerTraversalCallback::PreExpr(const zee case EXPR_INDEX: { - const auto* e = static_cast(expr); + const auto* e = static_cast(expr); Obj::SuppressErrors no_errors; try @@ -85,12 +85,12 @@ TraversalCode zeek::detail::trigger::TriggerTraversalCallback::PreExpr(const zee class TriggerTimer final : public Timer { public: TriggerTimer(double arg_timeout, Trigger* arg_trigger) - : Timer(zeek::run_state::network_time + arg_timeout, TIMER_TRIGGER) + : Timer(run_state::network_time + arg_timeout, TIMER_TRIGGER) { Ref(arg_trigger); trigger = arg_trigger; timeout = arg_timeout; - time = zeek::run_state::network_time; + time = run_state::network_time; } ~TriggerTimer() @@ -117,10 +117,10 @@ protected: double time; }; -Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body, - zeek::detail::Stmt* arg_timeout_stmts, - zeek::detail::Expr* arg_timeout, Frame* arg_frame, - bool arg_is_return, const Location* arg_location) +Trigger::Trigger(Expr* arg_cond, Stmt* arg_body, + Stmt* arg_timeout_stmts, + Expr* arg_timeout, Frame* arg_frame, + bool arg_is_return, const Location* arg_location) { cond = arg_cond; body = arg_body; @@ -135,14 +135,14 @@ Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body, location = arg_location; timeout_value = -1; - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: instantiating", Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: instantiating", Name()); if ( is_return ) { Trigger* parent = frame->GetTrigger(); if ( ! parent ) { - zeek::reporter->Error("return trigger in context which does not allow delaying result"); + reporter->Error("return trigger in context which does not allow delaying result"); Unref(this); return; } @@ -204,7 +204,7 @@ void Trigger::Terminate() Trigger::~Trigger() { - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: deleting", Name()); + DBG_LOG(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(zeek::DBG_NOTIFIERS, "%s: evaluating", Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: evaluating", Name()); if ( delayed ) { - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: skipping eval due to delayed call", + DBG_LOG(DBG_NOTIFIERS, "%s: skipping eval due to delayed call", Name()); return false; } @@ -262,7 +262,7 @@ bool Trigger::Eval() return false; } - f->SetTrigger({zeek::NewRef{}, this}); + f->SetTrigger({NewRef{}, this}); ValPtr v; @@ -277,7 +277,7 @@ bool Trigger::Eval() if ( f->HasDelayed() ) { - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: eval has delayed", Name()); + DBG_LOG(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(zeek::DBG_NOTIFIERS, "%s: trigger condition is false", Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: trigger condition is false", Name()); Unref(f); Init(); return false; } - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger condition is true, executing", + DBG_LOG(DBG_NOTIFIERS, "%s: trigger condition is true, executing", Name()); v = nullptr; @@ -313,8 +313,8 @@ bool Trigger::Eval() assert(trigger->attached == this); #ifdef DEBUG - const char* pname = zeek::util::copy_string(trigger->Name()); - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger has parent %s, caching result", Name(), pname); + const char* pname = util::copy_string(trigger->Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: trigger has parent %s, caching result", Name(), pname); delete [] pname; #endif @@ -344,11 +344,11 @@ void Trigger::Timeout() if ( disabled ) return; - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: timeout", Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: timeout", Name()); if ( timeout_stmts ) { StmtFlowType flow; - FramePtr f{zeek::AdoptRef{}, frame->Clone()}; + FramePtr f{AdoptRef{}, frame->Clone()}; ValPtr v; try @@ -366,8 +366,8 @@ void Trigger::Timeout() assert(trigger->attached == this); #ifdef DEBUG - const char* pname = zeek::util::copy_string(trigger->Name()); - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger has parent %s, caching timeout result", Name(), pname); + const char* pname = util::copy_string(trigger->Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: trigger has parent %s, caching timeout result", Name(), pname); delete [] pname; #endif auto queued = trigger->Cache(frame->GetCall(), v.get()); @@ -385,10 +385,10 @@ void Trigger::Timeout() Unref(this); } -void Trigger::Register(zeek::detail::ID* id) +void Trigger::Register(ID* id) { assert(! disabled); - zeek::notifier::detail::registry.Register(id, this); + notifier::detail::registry.Register(id, this); Ref(id); objs.push_back({id, id}); @@ -400,7 +400,7 @@ void Trigger::Register(Val* val) return; assert(! disabled); - zeek::notifier::detail::registry.Register(val->Modifiable(), this); + notifier::detail::registry.Register(val->Modifiable(), this); Ref(val); objs.emplace_back(val, val->Modifiable()); @@ -408,11 +408,11 @@ void Trigger::Register(Val* val) void Trigger::UnregisterAll() { - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: unregistering all", Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: unregistering all", Name()); for ( const auto& o : objs ) { - zeek::notifier::detail::registry.Unregister(o.second, this); + notifier::detail::registry.Unregister(o.second, this); Unref(o.first); } @@ -426,8 +426,8 @@ void Trigger::Attach(Trigger *trigger) assert(! trigger->delayed); #ifdef DEBUG - const char* pname = zeek::util::copy_string(trigger->Name()); - DBG_LOG(zeek::DBG_NOTIFIERS, "%s: attaching to %s", Name(), pname); + const char* pname = util::copy_string(trigger->Name()); + DBG_LOG(DBG_NOTIFIERS, "%s: attaching to %s", Name(), pname); delete [] pname; #endif @@ -436,7 +436,7 @@ void Trigger::Attach(Trigger *trigger) Hold(); } -bool Trigger::Cache(const zeek::detail::CallExpr* expr, Val* v) +bool Trigger::Cache(const CallExpr* expr, Val* v) { if ( disabled || ! v ) return false; @@ -454,12 +454,12 @@ bool Trigger::Cache(const zeek::detail::CallExpr* expr, Val* v) Ref(v); - zeek::detail::trigger_mgr->Queue(this); + trigger_mgr->Queue(this); return true; } -Val* Trigger::Lookup(const zeek::detail::CallExpr* expr) +Val* Trigger::Lookup(const CallExpr* expr) { assert(! disabled); @@ -478,24 +478,24 @@ void Trigger::Describe(ODesc* d) const d->Add(""); } -void Trigger::Modified(zeek::notifier::detail::Modifiable* m) +void Trigger::Modified(notifier::detail::Modifiable* m) { - zeek::detail::trigger_mgr->Queue(this); + trigger_mgr->Queue(this); } const char* Trigger::Name() const { assert(location); - return zeek::util::fmt("%s:%d-%d", location->filename, + return util::fmt("%s:%d-%d", location->filename, location->first_line, location->last_line); } -Manager::Manager() : zeek::iosource::IOSource() +Manager::Manager() : iosource::IOSource() { pending = new TriggerList(); - zeek::iosource_mgr->Register(this, true); + iosource_mgr->Register(this, true); } Manager::~Manager() @@ -505,12 +505,12 @@ Manager::~Manager() double Manager::GetNextTimeout() { - return pending->empty() ? -1 : zeek::run_state::network_time + 0.100; + return pending->empty() ? -1 : run_state::network_time + 0.100; } void Manager::Process() { - DBG_LOG(zeek::DBG_NOTIFIERS, "evaluating all pending triggers"); + DBG_LOG(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. @@ -540,7 +540,7 @@ void Manager::Queue(Trigger* trigger) Ref(trigger); pending->push_back(trigger); total_triggers++; - zeek::iosource_mgr->Wakeup(Tag()); + iosource_mgr->Wakeup(Tag()); } } diff --git a/src/Trigger.h b/src/Trigger.h index d12c3c4ccd..4aabedaa73 100644 --- a/src/Trigger.h +++ b/src/Trigger.h @@ -28,13 +28,13 @@ namespace trigger { class TriggerTimer; class TriggerTraversalCallback; -class Trigger final : public Obj, public zeek::notifier::detail::Receiver { +class Trigger final : public Obj, public notifier::detail::Receiver { public: // Don't access Trigger objects; they take care of themselves after // instantiation. Note that if the condition is already true, the // statements are executed immediately and the object is deleted // right away. - Trigger(zeek::detail::Expr* cond, zeek::detail::Stmt* body, zeek::detail::Stmt* timeout_stmts, zeek::detail::Expr* timeout, + Trigger(Expr* cond, Stmt* body, Stmt* timeout_stmts, Expr* timeout, Frame* f, bool is_return, const Location* loc); ~Trigger() override; @@ -65,8 +65,8 @@ public: // Cache for return values of delayed function calls. Returns whether // the trigger is queued for later evaluation -- it may not be queued // if the Val is null or it's disabled. - bool Cache(const zeek::detail::CallExpr* expr, Val* val); - Val* Lookup(const zeek::detail::CallExpr*); + bool Cache(const CallExpr* expr, Val* val); + Val* Lookup(const CallExpr*); // Disable this trigger completely. Needed because Unref'ing the trigger // may not immediately delete it as other references may still exist. @@ -92,14 +92,14 @@ private: friend class TriggerTimer; void Init(); - void Register(zeek::detail::ID* id); + void Register(ID* id); void Register(Val* val); void UnregisterAll(); - zeek::detail::Expr* cond; - zeek::detail::Stmt* body; - zeek::detail::Stmt* timeout_stmts; - zeek::detail::Expr* timeout; + Expr* cond; + Stmt* body; + Stmt* timeout_stmts; + Expr* timeout; double timeout_value; Frame* frame; bool is_return; @@ -111,15 +111,15 @@ private: bool delayed; // true if a function call is currently being delayed bool disabled; - std::vector> objs; + std::vector> objs; - using ValCache = std::map; + using ValCache = std::map; ValCache cache; }; -using TriggerPtr = zeek::IntrusivePtr; +using TriggerPtr = IntrusivePtr; -class Manager final : public zeek::iosource::IOSource { +class Manager final : public iosource::IOSource { public: Manager(); diff --git a/src/TunnelEncapsulation.cc b/src/TunnelEncapsulation.cc index 43e532c7bd..aaa744d9e3 100644 --- a/src/TunnelEncapsulation.cc +++ b/src/TunnelEncapsulation.cc @@ -18,19 +18,19 @@ EncapsulatingConn::EncapsulatingConn(Connection* c, BifEnum::Tunnel::Type t) } } -zeek::RecordValPtr EncapsulatingConn::ToVal() const +RecordValPtr EncapsulatingConn::ToVal() const { - auto rv = zeek::make_intrusive(zeek::BifType::Record::Tunnel::EncapsulatingConn); + auto rv = make_intrusive(BifType::Record::Tunnel::EncapsulatingConn); - auto id_val = zeek::make_intrusive(zeek::id::conn_id); - id_val->Assign(0, zeek::make_intrusive(src_addr)); - id_val->Assign(1, zeek::val_mgr->Port(ntohs(src_port), proto)); - id_val->Assign(2, zeek::make_intrusive(dst_addr)); - id_val->Assign(3, zeek::val_mgr->Port(ntohs(dst_port), proto)); + auto id_val = make_intrusive(id::conn_id); + id_val->Assign(0, make_intrusive(src_addr)); + id_val->Assign(1, val_mgr->Port(ntohs(src_port), proto)); + id_val->Assign(2, make_intrusive(dst_addr)); + id_val->Assign(3, val_mgr->Port(ntohs(dst_port), proto)); rv->Assign(0, std::move(id_val)); - rv->Assign(1, zeek::BifType::Enum::Tunnel::Type->GetEnumVal(type)); + rv->Assign(1, BifType::Enum::Tunnel::Type->GetEnumVal(type)); - rv->Assign(2, zeek::make_intrusive(uid.Base62("C").c_str())); + rv->Assign(2, make_intrusive(uid.Base62("C").c_str())); return rv; } diff --git a/src/TunnelEncapsulation.h b/src/TunnelEncapsulation.h index 89003017b9..06bb774e4a 100644 --- a/src/TunnelEncapsulation.h +++ b/src/TunnelEncapsulation.h @@ -42,11 +42,11 @@ public: * @param d The tunnel destination address, likely taken from an IP header. * @param t The type of IP tunnel. */ - EncapsulatingConn(const zeek::IPAddr& s, const zeek::IPAddr& d, + EncapsulatingConn(const IPAddr& s, const IPAddr& d, BifEnum::Tunnel::Type t = BifEnum::Tunnel::IP) : src_addr(s), dst_addr(d), src_port(0), dst_port(0), proto(TRANSPORT_UNKNOWN), type(t), - uid(zeek::UID(detail::bits_per_uid)) + uid(UID(detail::bits_per_uid)) { } @@ -82,10 +82,10 @@ public: /** * Returns record value of type "EncapsulatingConn" representing the tunnel. */ - zeek::RecordValPtr ToVal() const; + RecordValPtr ToVal() const; [[deprecated("Remove in v4.1. Use ToVal() instead.")]] - zeek::RecordVal* GetRecordVal() const + RecordVal* GetRecordVal() const { return ToVal().release(); } friend bool operator==(const EncapsulatingConn& ec1, @@ -121,13 +121,13 @@ public: } protected: - zeek::IPAddr src_addr; - zeek::IPAddr dst_addr; + IPAddr src_addr; + IPAddr dst_addr; uint16_t src_port; uint16_t dst_port; TransportProto proto; BifEnum::Tunnel::Type type; - zeek::UID uid; + UID uid; }; /** @@ -197,10 +197,10 @@ public: * Get the value of type "EncapsulatingConnVector" represented by the * entire encapsulation chain. */ - zeek::VectorValPtr ToVal() const + VectorValPtr ToVal() const { - auto vv = zeek::make_intrusive( - zeek::id::find_type("EncapsulatingConnVector")); + auto vv = make_intrusive( + id::find_type("EncapsulatingConnVector")); if ( conns ) { @@ -212,7 +212,7 @@ public: } [[deprecated("Remove in v4.1. Use ToVal() instead.")]] - zeek::VectorVal* GetVectorVal() const + VectorVal* GetVectorVal() const { return ToVal().release(); } friend bool operator==(const EncapsulationStack& e1, diff --git a/src/Type.cc b/src/Type.cc index 4dc15f9114..f4330ede72 100644 --- a/src/Type.cc +++ b/src/Type.cc @@ -27,7 +27,7 @@ namespace zeek { Type::TypeAliasMap Type::type_aliases; // Note: This function must be thread-safe. -const char* type_name(zeek::TypeTag t) +const char* type_name(TypeTag t) { static constexpr const char* type_names[int(NUM_TYPES)] = { "void", // 0 @@ -64,7 +64,7 @@ const char* type_name(zeek::TypeTag t) return type_names[int(t)]; } -Type::Type(zeek::TypeTag t, bool arg_base_type) +Type::Type(TypeTag t, bool arg_base_type) : tag(t), internal_tag(to_internal_type_tag(tag)), is_network_order(zeek::is_network_order(t)), base_type(arg_base_type) @@ -213,22 +213,22 @@ TypePtr Type::ShallowClone() case TYPE_ADDR: case TYPE_SUBNET: case TYPE_ANY: - return zeek::make_intrusive(tag, base_type); + return make_intrusive(tag, base_type); default: - zeek::reporter->InternalError("cloning illegal base Type"); + reporter->InternalError("cloning illegal base Type"); } return nullptr; } -int Type::MatchesIndex(zeek::detail::ListExpr* const index) const +int Type::MatchesIndex(detail::ListExpr* const index) const { if ( Tag() == TYPE_STRING ) { if ( index->Exprs().length() != 1 && index->Exprs().length() != 2 ) return DOES_NOT_MATCH_INDEX; - if ( check_and_promote_exprs_to_type(index, zeek::base_type(zeek::TYPE_INT).get()) ) + if ( check_and_promote_exprs_to_type(index, zeek::base_type(TYPE_INT).get()) ) return MATCHES_INDEX_SCALAR; } @@ -266,7 +266,7 @@ void Type::Describe(ODesc* d) const void Type::DescribeReST(ODesc* d, bool roles_only) const { - d->Add(zeek::util::fmt(":zeek:type:`%s`", type_name(Tag()))); + d->Add(util::fmt(":zeek:type:`%s`", type_name(Tag()))); } void Type::SetError() @@ -290,7 +290,7 @@ bool TypeList::AllMatch(const Type* t, bool is_init) const void TypeList::Append(TypePtr t) { if ( pure_type && ! same_type(t, pure_type) ) - zeek::reporter->InternalError("pure type-list violation"); + reporter->InternalError("pure type-list violation"); types_list.push_back(t.get()); types.emplace_back(std::move(t)); @@ -339,14 +339,14 @@ unsigned int TypeList::MemoryAllocation() const for ( const auto& t : types ) size += t->MemoryAllocation(); - size += zeek::util::pad_size(types.capacity() * sizeof(decltype(types)::value_type)); + size += util::pad_size(types.capacity() * sizeof(decltype(types)::value_type)); return Type::MemoryAllocation() + padded_sizeof(*this) - padded_sizeof(Type) + size; } -int IndexType::MatchesIndex(zeek::detail::ListExpr* const index) const +int IndexType::MatchesIndex(detail::ListExpr* const index) const { // If we have a type indexed by subnets, addresses are ok. const auto& types = indices->GetTypes(); @@ -470,7 +470,7 @@ TableType::TableType(TypeListPtr ind, TypePtr yield) TypePtr TableType::ShallowClone() { - return zeek::make_intrusive(indices, yield_type); + return make_intrusive(indices, yield_type); } bool TableType::IsUnspecifiedTable() const @@ -479,7 +479,7 @@ bool TableType::IsUnspecifiedTable() const return indices->GetTypes().empty(); } -SetType::SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements) +SetType::SetType(TypeListPtr ind, detail::ListExprPtr arg_elements) : TableType(std::move(ind), nullptr), elements(std::move(arg_elements)) { if ( elements ) @@ -502,8 +502,8 @@ SetType::SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements) else if ( tl.size() == 1 ) { - TypePtr ft{zeek::NewRef{}, flatten_type(tl[0].get())}; - indices = zeek::make_intrusive(ft); + TypePtr ft{NewRef{}, flatten_type(tl[0].get())}; + indices = make_intrusive(ft); indices->Append(std::move(ft)); } @@ -520,7 +520,7 @@ SetType::SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements) return; } - indices = zeek::make_intrusive(t); + indices = make_intrusive(t); indices->Append(std::move(t)); } } @@ -529,7 +529,7 @@ SetType::SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements) TypePtr SetType::ShallowClone() { - return zeek::make_intrusive(indices, elements); + return make_intrusive(indices, elements); } SetType::~SetType() = default; @@ -537,7 +537,7 @@ SetType::~SetType() = default; FuncType::FuncType(RecordTypePtr arg_args, TypePtr arg_yield, FunctionFlavor arg_flavor) : Type(TYPE_FUNC), args(std::move(arg_args)), - arg_types(zeek::make_intrusive()), yield(std::move(arg_yield)) + arg_types(make_intrusive()), yield(std::move(arg_yield)) { flavor = arg_flavor; @@ -548,13 +548,13 @@ FuncType::FuncType(RecordTypePtr arg_args, { const TypeDecl* td = args->FieldDecl(i); - if ( td->attrs && td->attrs->Find(zeek::detail::ATTR_DEFAULT) ) + if ( td->attrs && td->attrs->Find(detail::ATTR_DEFAULT) ) has_default_arg = true; else if ( has_default_arg ) { - const char* err_str = zeek::util::fmt("required parameter '%s' must precede " - "default parameters", td->id); + const char* err_str = util::fmt("required parameter '%s' must precede " + "default parameters", td->id); args->Error(err_str); } @@ -567,7 +567,7 @@ FuncType::FuncType(RecordTypePtr arg_args, TypePtr FuncType::ShallowClone() { - auto f = zeek::make_intrusive(); + auto f = make_intrusive(); f->args = args; f->arg_types = arg_types; f->yield = yield; @@ -590,14 +590,14 @@ string FuncType::FlavorString() const return "hook"; default: - zeek::reporter->InternalError("Invalid function flavor"); + reporter->InternalError("Invalid function flavor"); return "invalid_func_flavor"; } } FuncType::~FuncType() = default; -int FuncType::MatchesIndex(zeek::detail::ListExpr* const index) const +int FuncType::MatchesIndex(detail::ListExpr* const index) const { return check_and_promote_args(index, args.get()) ? MATCHES_INDEX_SCALAR : DOES_NOT_MATCH_INDEX; @@ -609,7 +609,7 @@ bool FuncType::CheckArgs(const TypePList* args, bool is_init) const as.reserve(args->length()); for ( auto a : *args ) - as.emplace_back(zeek::NewRef{}, a); + as.emplace_back(NewRef{}, a); return CheckArgs(as, is_init); } @@ -621,8 +621,8 @@ bool FuncType::CheckArgs(const std::vector& args, if ( my_args.size() != args.size() ) { - Warn(zeek::util::fmt("Wrong number of arguments for function. Expected %zu, got %zu.", - args.size(), my_args.size())); + Warn(util::fmt("Wrong number of arguments for function. Expected %zu, got %zu.", + args.size(), my_args.size())); return false; } @@ -631,8 +631,8 @@ bool FuncType::CheckArgs(const std::vector& args, for ( size_t i = 0; i < my_args.size(); ++i ) if ( ! same_type(args[i], my_args[i], is_init) ) { - Warn(zeek::util::fmt("Type mismatch in function argument #%zu. Expected %s, got %s.", - i, type_name(args[i]->Tag()), type_name(my_args[i]->Tag()))); + Warn(util::fmt("Type mismatch in function argument #%zu. Expected %s, got %s.", + i, type_name(args[i]->Tag()), type_name(my_args[i]->Tag()))); success = false; } @@ -719,7 +719,7 @@ std::optional FuncType::FindPrototype(const RecordType& arg const auto& desired_type = args.GetFieldType(i); if ( ! same_type(ptype, desired_type) || - ! zeek::util::streq(args.FieldName(i), p.args->FieldName(i)) ) + ! util::streq(args.FieldName(i), p.args->FieldName(i)) ) { matched = false; break; @@ -733,7 +733,7 @@ std::optional FuncType::FindPrototype(const RecordType& arg return {}; } -TypeDecl::TypeDecl(const char* i, TypePtr t, zeek::detail::AttributesPtr arg_attrs) +TypeDecl::TypeDecl(const char* i, TypePtr t, detail::AttributesPtr arg_attrs) : type(std::move(t)), attrs(std::move(arg_attrs)), id(i) @@ -744,7 +744,7 @@ TypeDecl::TypeDecl(const TypeDecl& other) type = other.type; attrs = other.attrs; - id = zeek::util::copy_string(other.id); + id = util::copy_string(other.id); } TypeDecl::~TypeDecl() @@ -786,7 +786,7 @@ TypePtr RecordType::ShallowClone() auto pass = new type_decl_list(); for ( const auto& type : *types ) pass->push_back(new TypeDecl(*type)); - return zeek::make_intrusive(pass); + return make_intrusive(pass); } RecordType::~RecordType() @@ -812,7 +812,7 @@ ValPtr RecordType::FieldDefault(int field) const if ( ! td->attrs ) return nullptr; - const auto& def_attr = td->attrs->Find(zeek::detail::ATTR_DEFAULT); + const auto& def_attr = td->attrs->Find(detail::ATTR_DEFAULT); return def_attr ? def_attr->GetExpr()->Eval(nullptr) : nullptr; } @@ -821,7 +821,7 @@ int RecordType::FieldOffset(const char* field) const loop_over_list(*types, i) { TypeDecl* td = (*types)[i]; - if ( zeek::util::streq(td->id, field) ) + if ( util::streq(td->id, field) ) return i; } @@ -919,9 +919,9 @@ static string container_type_name(const Type* ft) TableValPtr RecordType::GetRecordFieldsVal(const RecordVal* rv) const { - static auto record_field = zeek::id::find_type("record_field"); - static auto record_field_table = zeek::id::find_type("record_field_table"); - auto rval = zeek::make_intrusive(record_field_table); + static auto record_field = id::find_type("record_field"); + static auto record_field_table = id::find_type("record_field_table"); + auto rval = make_intrusive(record_field_table); for ( int i = 0; i < NumFields(); ++i ) { @@ -932,16 +932,16 @@ TableValPtr RecordType::GetRecordFieldsVal(const RecordVal* rv) const if ( rv ) fv = rv->GetField(i); - bool logged = (fd->attrs && fd->GetAttr(zeek::detail::ATTR_LOG) != nullptr); + bool logged = (fd->attrs && fd->GetAttr(detail::ATTR_LOG) != nullptr); - auto nr = zeek::make_intrusive(record_field); + auto nr = make_intrusive(record_field); string s = container_type_name(ft.get()); - nr->Assign(0, zeek::make_intrusive(s)); - nr->Assign(1, zeek::val_mgr->Bool(logged)); + nr->Assign(0, make_intrusive(s)); + nr->Assign(1, val_mgr->Bool(logged)); nr->Assign(2, std::move(fv)); nr->Assign(3, FieldDefault(i)); - auto field_name = zeek::make_intrusive(FieldName(i)); + auto field_name = make_intrusive(FieldName(i)); rval->Assign(std::move(field_name), std::move(nr)); } @@ -957,7 +957,7 @@ const char* RecordType::AddFields(const type_decl_list& others, for ( const auto& td : others ) { - if ( ! td->GetAttr(zeek::detail::ATTR_DEFAULT) && ! td->GetAttr(zeek::detail::ATTR_OPTIONAL) ) + if ( ! td->GetAttr(detail::ATTR_DEFAULT) && ! td->GetAttr(detail::ATTR_OPTIONAL) ) return "extension field must be &optional or have &default"; } @@ -968,9 +968,9 @@ const char* RecordType::AddFields(const type_decl_list& others, if ( add_log_attr ) { if ( ! td->attrs ) - td->attrs = zeek::make_intrusive(td->type, true, false); + td->attrs = make_intrusive(td->type, true, false); - td->attrs->AddAttr(zeek::make_intrusive(zeek::detail::ATTR_LOG)); + td->attrs->AddAttr(make_intrusive(detail::ATTR_LOG)); } types->push_back(td); @@ -1045,7 +1045,7 @@ void RecordType::DescribeFieldsReST(ODesc* d, bool func_args) const d->Add(""); else { - if ( num_fields == 1 && zeek::util::streq(td->id, "va_args") && + if ( num_fields == 1 && util::streq(td->id, "va_args") && td->type->Tag() == TYPE_ANY ) // This was a BIF using variable argument list d->Add("..."); @@ -1056,12 +1056,12 @@ void RecordType::DescribeFieldsReST(ODesc* d, bool func_args) const if ( func_args ) continue; - zeek::zeekygen::detail::IdentifierInfo* doc = zeek::detail::zeekygen_mgr->GetIdentifierInfo(GetName()); + zeekygen::detail::IdentifierInfo* doc = detail::zeekygen_mgr->GetIdentifierInfo(GetName()); if ( ! doc ) { - zeek::reporter->InternalWarning("Failed to lookup record doc: %s", - GetName().c_str()); + reporter->InternalWarning("Failed to lookup record doc: %s", + GetName().c_str()); continue; } @@ -1075,7 +1075,7 @@ void RecordType::DescribeFieldsReST(ODesc* d, bool func_args) const field_from_script != type_from_script ) { d->PushIndent(); - d->Add(zeek::zeekygen::detail::redef_indication(field_from_script).c_str()); + d->Add(zeekygen::detail::redef_indication(field_from_script).c_str()); d->PopIndent(); } @@ -1095,7 +1095,7 @@ void RecordType::DescribeFieldsReST(ODesc* d, bool func_args) const { string s = cmnts[i]; - if ( zeek::zeekygen::detail::prettify_params(s) ) + if ( zeekygen::detail::prettify_params(s) ) d->NL(); d->Add(s.c_str()); @@ -1117,15 +1117,15 @@ string RecordType::GetFieldDeprecationWarning(int field, bool has_check) const if ( decl) { string result; - if ( const auto& deprecation = decl->GetAttr(zeek::detail::ATTR_DEPRECATED) ) + if ( const auto& deprecation = decl->GetAttr(detail::ATTR_DEPRECATED) ) result = deprecation->DeprecationMessage(); if ( result.empty() ) - return zeek::util::fmt("deprecated (%s%s$%s)", GetName().c_str(), has_check ? "?" : "", - FieldName(field)); + return util::fmt("deprecated (%s%s$%s)", GetName().c_str(), has_check ? "?" : "", + FieldName(field)); else - return zeek::util::fmt("deprecated (%s%s$%s): %s", GetName().c_str(), has_check ? "?" : "", - FieldName(field), result.c_str()); + return util::fmt("deprecated (%s%s$%s): %s", GetName().c_str(), has_check ? "?" : "", + FieldName(field), result.c_str()); } return ""; @@ -1181,7 +1181,7 @@ void OpaqueType::Describe(ODesc* d) const void OpaqueType::DescribeReST(ODesc* d, bool roles_only) const { - d->Add(zeek::util::fmt(":zeek:type:`%s` of %s", type_name(Tag()), name.c_str())); + d->Add(util::fmt(":zeek:type:`%s` of %s", type_name(Tag()), name.c_str())); } EnumType::EnumType(const string& name) @@ -1201,22 +1201,23 @@ EnumType::EnumType(const EnumType* e) TypePtr EnumType::ShallowClone() { if ( counter == 0 ) - return zeek::make_intrusive(GetName()); + return make_intrusive(GetName()); - return zeek::make_intrusive(this); + return make_intrusive(this); } EnumType::~EnumType() = default; -// Note, we use zeek::reporter->Error() here (not Error()) to include the current script +// Note, we use reporter->Error() here (not Error()) to include the current script // location in the error message, rather than the one where the type was // originally defined. -void EnumType::AddName(const string& module_name, const char* name, bool is_export, zeek::detail::Expr* deprecation) +void EnumType::AddName(const string& module_name, const char* name, bool is_export, + detail::Expr* deprecation) { /* implicit, auto-increment */ if ( counter < 0) { - zeek::reporter->Error("cannot mix explicit enumerator assignment and implicit auto-increment"); + reporter->Error("cannot mix explicit enumerator assignment and implicit auto-increment"); SetError(); return; } @@ -1224,12 +1225,13 @@ void EnumType::AddName(const string& module_name, const char* name, bool is_expo counter++; } -void EnumType::AddName(const string& module_name, const char* name, bro_int_t val, bool is_export, zeek::detail::Expr* deprecation) +void EnumType::AddName(const string& module_name, const char* name, bro_int_t val, + bool is_export, detail::Expr* deprecation) { /* explicit value specified */ if ( counter > 0 ) { - zeek::reporter->Error("cannot mix explicit enumerator assignment and implicit auto-increment"); + reporter->Error("cannot mix explicit enumerator assignment and implicit auto-increment"); SetError(); return; } @@ -1238,28 +1240,28 @@ void EnumType::AddName(const string& module_name, const char* name, bro_int_t va } void EnumType::CheckAndAddName(const string& module_name, const char* name, - bro_int_t val, bool is_export, zeek::detail::Expr* deprecation) + bro_int_t val, bool is_export, detail::Expr* deprecation) { if ( Lookup(val) ) { - zeek::reporter->Error("enumerator value in enumerated type definition already exists"); + reporter->Error("enumerator value in enumerated type definition already exists"); SetError(); return; } - auto fullname = zeek::detail::make_full_var_name(module_name.c_str(), name); - auto id = zeek::id::find(fullname); + auto fullname = detail::make_full_var_name(module_name.c_str(), name); + auto id = id::find(fullname); if ( ! id ) { - id = zeek::detail::install_ID(name, module_name.c_str(), true, is_export); - id->SetType({zeek::NewRef{}, this}); + id = detail::install_ID(name, module_name.c_str(), true, is_export); + id->SetType({NewRef{}, this}); id->SetEnumConst(); if ( deprecation ) - id->MakeDeprecated({zeek::NewRef{}, deprecation}); + id->MakeDeprecated({NewRef{}, deprecation}); - zeek::detail::zeekygen_mgr->Identifier(std::move(id)); + detail::zeekygen_mgr->Identifier(std::move(id)); } else { @@ -1284,7 +1286,7 @@ void EnumType::CheckAndAddName(const string& module_name, const char* name, AddNameInternal(module_name, name, val, is_export); if ( vals.find(val) == vals.end() ) - vals[val] = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, this}, val); + vals[val] = make_intrusive(IntrusivePtr{NewRef{}, this}, val); set types = Type::GetAliases(GetName()); set::const_iterator it; @@ -1298,14 +1300,14 @@ void EnumType::CheckAndAddName(const string& module_name, const char* name, void EnumType::AddNameInternal(const string& module_name, const char* name, bro_int_t val, bool is_export) { - string fullname = zeek::detail::make_full_var_name(module_name.c_str(), name); + string fullname = detail::make_full_var_name(module_name.c_str(), name); names[fullname] = val; } bro_int_t EnumType::Lookup(const string& module_name, const char* name) const { NameMap::const_iterator pos = - names.find(zeek::detail::make_full_var_name(module_name.c_str(), name).c_str()); + names.find(detail::make_full_var_name(module_name.c_str(), name).c_str()); if ( pos == names.end() ) return -1; @@ -1339,14 +1341,14 @@ const EnumValPtr& EnumType::GetEnumVal(bro_int_t i) if ( it == vals.end() ) { - auto ev = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, this}, i); + auto ev = make_intrusive(IntrusivePtr{NewRef{}, this}, i); return vals.emplace(i, std::move(ev)).first->second; } return it->second; } -zeek::EnumVal* EnumType::GetVal(bro_int_t i) +EnumVal* EnumType::GetVal(bro_int_t i) { auto rval = GetEnumVal(i).get(); zeek::Ref(rval); @@ -1372,16 +1374,16 @@ void EnumType::DescribeReST(ODesc* d, bool roles_only) const d->PushIndent(); if ( roles_only ) - d->Add(zeek::util::fmt(":zeek:enum:`%s`", it->second.c_str())); + d->Add(util::fmt(":zeek:enum:`%s`", it->second.c_str())); else - d->Add(zeek::util::fmt(".. zeek:enum:: %s %s", it->second.c_str(), GetName().c_str())); + d->Add(util::fmt(".. zeek:enum:: %s %s", it->second.c_str(), GetName().c_str())); - zeek::zeekygen::detail::IdentifierInfo* doc = zeek::detail::zeekygen_mgr->GetIdentifierInfo(it->second); + zeekygen::detail::IdentifierInfo* doc = detail::zeekygen_mgr->GetIdentifierInfo(it->second); if ( ! doc ) { - zeek::reporter->InternalWarning("Enum %s documentation lookup failure", - it->second.c_str()); + reporter->InternalWarning("Enum %s documentation lookup failure", + it->second.c_str()); continue; } @@ -1391,7 +1393,7 @@ void EnumType::DescribeReST(ODesc* d, bool roles_only) const if ( doc->GetDeclaringScript() ) enum_from_script = doc->GetDeclaringScript()->Name(); - zeek::zeekygen::detail::IdentifierInfo* type_doc = zeek::detail::zeekygen_mgr->GetIdentifierInfo(GetName()); + zeekygen::detail::IdentifierInfo* type_doc = detail::zeekygen_mgr->GetIdentifierInfo(GetName()); if ( type_doc && type_doc->GetDeclaringScript() ) type_from_script = type_doc->GetDeclaringScript()->Name(); @@ -1401,7 +1403,7 @@ void EnumType::DescribeReST(ODesc* d, bool roles_only) const { d->NL(); d->PushIndent(); - d->Add(zeek::zeekygen::detail::redef_indication(enum_from_script).c_str()); + d->Add(zeekygen::detail::redef_indication(enum_from_script).c_str()); d->PopIndent(); } @@ -1436,7 +1438,7 @@ VectorType::VectorType(TypePtr element_type) TypePtr VectorType::ShallowClone() { - return zeek::make_intrusive(yield_type); + return make_intrusive(yield_type); } VectorType::~VectorType() = default; @@ -1448,12 +1450,12 @@ const TypePtr& VectorType::Yield() const // return any as that's what other code historically expects for type // comparisions. if ( IsUnspecifiedVector() ) - return zeek::base_type(zeek::TYPE_ANY); + return zeek::base_type(TYPE_ANY); return yield_type; } -int VectorType::MatchesIndex(zeek::detail::ListExpr* const index) const +int VectorType::MatchesIndex(detail::ListExpr* const index) const { ExprPList& el = index->Exprs(); @@ -1489,12 +1491,12 @@ void VectorType::Describe(ODesc* d) const void VectorType::DescribeReST(ODesc* d, bool roles_only) const { - d->Add(zeek::util::fmt(":zeek:type:`%s` of ", type_name(Tag()))); + d->Add(util::fmt(":zeek:type:`%s` of ", type_name(Tag()))); if ( yield_type->GetName().empty() ) yield_type->DescribeReST(d, roles_only); else - d->Add(zeek::util::fmt(":zeek:type:`%s`", yield_type->GetName().c_str())); + d->Add(util::fmt(":zeek:type:`%s`", yield_type->GetName().c_str())); } // Returns true if t1 is initialization-compatible with t2 (i.e., if an @@ -1626,7 +1628,7 @@ bool same_type(const Type& arg_t1, const Type& arg_t2, const TypeDecl* td1 = rt1->FieldDecl(i); const TypeDecl* td2 = rt2->FieldDecl(i); - if ( (match_record_field_names && ! zeek::util::streq(td1->id, td2->id)) || + if ( (match_record_field_names && ! util::streq(td1->id, td2->id)) || ! same_type(td1->type, td2->type, is_init, match_record_field_names) ) return false; } @@ -1669,12 +1671,12 @@ bool same_type(const Type& arg_t1, const Type& arg_t2, } case TYPE_UNION: - zeek::reporter->Error("union type in same_type()"); + reporter->Error("union type in same_type()"); } return false; } -bool same_attrs(const zeek::detail::Attributes* a1, const zeek::detail::Attributes* a2) +bool same_attrs(const detail::Attributes* a1, const detail::Attributes* a2) { if ( ! a1 ) return (a2 == nullptr); @@ -1729,7 +1731,7 @@ const Type* flatten_type(const Type* t) const auto& types = tl->GetTypes(); if ( types.size() == 0 ) - zeek::reporter->InternalError("empty type list in flatten_type"); + reporter->InternalError("empty type list in flatten_type"); const auto& ft = types[0]; @@ -1782,7 +1784,7 @@ bool is_assignable(TypeTag t) return false; case TYPE_UNION: - zeek::reporter->Error("union type in is_assignable()"); + reporter->Error("union type in is_assignable()"); } return false; @@ -1809,7 +1811,7 @@ TypeTag max_type(TypeTag t1, TypeTag t2) } else { - zeek::reporter->InternalError("non-arithmetic tags in max_type()"); + reporter->InternalError("non-arithmetic tags in max_type()"); return TYPE_ERROR; } } @@ -1854,8 +1856,8 @@ TypePtr merge_types(const TypePtr& arg_t1, // there creating clones of the type, so safer to compare name. if ( t1->GetName() != t2->GetName() ) { - std::string msg = zeek::util::fmt("incompatible enum types: '%s' and '%s'", - t1->GetName().data(), t2->GetName().data()); + std::string msg = util::fmt("incompatible enum types: '%s' and '%s'", + t1->GetName().data(), t2->GetName().data()); t1->Error(msg.data(), t2); return nullptr; @@ -1864,7 +1866,7 @@ TypePtr merge_types(const TypePtr& arg_t1, // Doing a lookup here as a roundabout way of ref-ing t1, without // changing the function params which has t1 as const and also // (potentially) avoiding a pitfall mentioned earlier about clones. - const auto& id = zeek::detail::global_scope()->Find(t1->GetName()); + const auto& id = detail::global_scope()->Find(t1->GetName()); if ( id && id->IsType() && id->GetType()->Tag() == TYPE_ENUM ) // It should make most sense to return the real type here rather @@ -1873,10 +1875,10 @@ TypePtr merge_types(const TypePtr& arg_t1, // actually see those changes from the redef. return id->GetType(); - std::string msg = zeek::util::fmt("incompatible enum types: '%s' and '%s'" - " ('%s' enum type ID is invalid)", - t1->GetName().data(), t2->GetName().data(), - t1->GetName().data()); + std::string msg = util::fmt("incompatible enum types: '%s' and '%s'" + " ('%s' enum type ID is invalid)", + t1->GetName().data(), t2->GetName().data(), + t1->GetName().data()); t1->Error(msg.data(), t2); return nullptr; } @@ -1896,7 +1898,7 @@ TypePtr merge_types(const TypePtr& arg_t1, return nullptr; } - tl3 = zeek::make_intrusive(); + tl3 = make_intrusive(); for ( auto i = 0u; i < tl1.size(); ++i ) { @@ -1925,9 +1927,9 @@ TypePtr merge_types(const TypePtr& arg_t1, } if ( t1->IsSet() ) - return zeek::make_intrusive(std::move(tl3), nullptr); + return make_intrusive(std::move(tl3), nullptr); else - return zeek::make_intrusive(std::move(tl3), std::move(y3)); + return make_intrusive(std::move(tl3), std::move(y3)); } case TYPE_FUNC: @@ -1940,12 +1942,12 @@ TypePtr merge_types(const TypePtr& arg_t1, const FuncType* ft1 = (const FuncType*) t1; const FuncType* ft2 = (const FuncType*) t1; - auto args = zeek::cast_intrusive(merge_types(ft1->Params(), + auto args = cast_intrusive(merge_types(ft1->Params(), ft2->Params())); auto yield = t1->Yield() ? merge_types(t1->Yield(), t2->Yield()) : nullptr; - return zeek::make_intrusive(std::move(args), std::move(yield), + return make_intrusive(std::move(args), std::move(yield), ft1->Flavor()); } @@ -1965,17 +1967,17 @@ TypePtr merge_types(const TypePtr& arg_t1, const TypeDecl* td2 = rt2->FieldDecl(i); auto tdl3_i = merge_types(td1->type, td2->type); - if ( ! zeek::util::streq(td1->id, td2->id) || ! tdl3_i ) + if ( ! util::streq(td1->id, td2->id) || ! tdl3_i ) { t1->Error("incompatible record fields", t2); delete tdl3; return nullptr; } - tdl3->push_back(new TypeDecl(zeek::util::copy_string(td1->id), std::move(tdl3_i))); + tdl3->push_back(new TypeDecl(util::copy_string(td1->id), std::move(tdl3_i))); } - return zeek::make_intrusive(tdl3); + return make_intrusive(tdl3); } case TYPE_LIST: @@ -2018,7 +2020,7 @@ TypePtr merge_types(const TypePtr& arg_t1, return nullptr; } - auto tl3 = zeek::make_intrusive(); + auto tl3 = make_intrusive(); for ( auto i = 0u; i < l1.size(); ++i ) tl3->Append(merge_types(l1[i], l2[i])); @@ -2033,7 +2035,7 @@ TypePtr merge_types(const TypePtr& arg_t1, return nullptr; } - return zeek::make_intrusive(merge_types(t1->Yield(), t2->Yield())); + return make_intrusive(merge_types(t1->Yield(), t2->Yield())); case TYPE_FILE: if ( ! same_type(t1->Yield(), t2->Yield()) ) @@ -2042,26 +2044,26 @@ TypePtr merge_types(const TypePtr& arg_t1, return nullptr; } - return zeek::make_intrusive(merge_types(t1->Yield(), t2->Yield())); + return make_intrusive(merge_types(t1->Yield(), t2->Yield())); case TYPE_UNION: - zeek::reporter->InternalError("union type in merge_types()"); + reporter->InternalError("union type in merge_types()"); return nullptr; default: - zeek::reporter->InternalError("bad type in merge_types()"); + reporter->InternalError("bad type in merge_types()"); return nullptr; } } -TypePtr merge_type_list(zeek::detail::ListExpr* elements) +TypePtr merge_type_list(detail::ListExpr* elements) { TypeList* tl_type = elements->GetType()->AsTypeList(); const auto& tl = tl_type->GetTypes(); if ( tl.size() < 1 ) { - zeek::reporter->Error("no type can be inferred for empty list"); + reporter->Error("no type can be inferred for empty list"); return nullptr; } @@ -2074,7 +2076,7 @@ TypePtr merge_type_list(zeek::detail::ListExpr* elements) t = merge_types(t, tl[i]); if ( ! t ) - zeek::reporter->Error("inconsistent types in list"); + reporter->Error("inconsistent types in list"); return t; } @@ -2099,9 +2101,9 @@ static Type* reduce_type(Type* t) return t; } -TypePtr init_type(zeek::detail::Expr* init) +TypePtr init_type(detail::Expr* init) { - if ( init->Tag() != zeek::detail::EXPR_LIST ) + if ( init->Tag() != detail::EXPR_LIST ) { auto t = init->InitType(); @@ -2118,7 +2120,7 @@ TypePtr init_type(zeek::detail::Expr* init) return t; } - zeek::detail::ListExpr* init_list = init->AsListExpr(); + detail::ListExpr* init_list = init->AsListExpr(); const ExprPList& el = init_list->Exprs(); if ( el.length() == 0 ) @@ -2128,7 +2130,7 @@ TypePtr init_type(zeek::detail::Expr* init) } // Could be a record, a set, or a list of table elements. - zeek::detail::Expr* e0 = el[0]; + detail::Expr* e0 = el[0]; if ( e0->IsRecordElement(nullptr) ) // ListExpr's know how to build a record from their @@ -2138,7 +2140,7 @@ TypePtr init_type(zeek::detail::Expr* init) auto t = e0->InitType(); if ( t ) - t = {zeek::NewRef{}, reduce_type(t.get())}; + t = {NewRef{}, reduce_type(t.get())}; if ( ! t ) return nullptr; @@ -2149,7 +2151,7 @@ TypePtr init_type(zeek::detail::Expr* init) TypePtr ti; if ( el_t ) - ti = {zeek::NewRef{}, reduce_type(el_t.get())}; + ti = {NewRef{}, reduce_type(el_t.get())}; if ( ! ti ) return nullptr; @@ -2174,12 +2176,12 @@ TypePtr init_type(zeek::detail::Expr* init) // it one, as that's what's required for creating a set type. if ( t->Tag() != TYPE_LIST ) { - auto tl = zeek::make_intrusive(t); + auto tl = make_intrusive(t); tl->Append(std::move(t)); t = std::move(tl); } - return zeek::make_intrusive(zeek::cast_intrusive(std::move(t)), + return make_intrusive(cast_intrusive(std::move(t)), nullptr); } @@ -2198,16 +2200,16 @@ bool is_atomic_type(const Type& t) } } -const TypePtr& base_type(zeek::TypeTag tag) +const TypePtr& base_type(TypeTag tag) { static TypePtr base_types[NUM_TYPES]; // We could check here that "tag" actually corresponds to a basic type. if ( ! base_types[tag] ) { - base_types[tag] = zeek::make_intrusive(tag, true); + base_types[tag] = make_intrusive(tag, true); // Give the base types a pseudo-location for easier identification. - zeek::detail::Location l(type_name(tag), 0, 0, 0, 0); + detail::Location l(type_name(tag), 0, 0, 0, 0); base_types[tag]->SetLocationInfo(&l); } diff --git a/src/Type.h b/src/Type.h index 0d4f40c0f5..545fb54b3f 100644 --- a/src/Type.h +++ b/src/Type.h @@ -22,16 +22,14 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(ListExpr, zeek::detail); ZEEK_FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail); namespace zeek { -using ValPtr = zeek::IntrusivePtr; -using EnumValPtr = zeek::IntrusivePtr; -using TableValPtr = zeek::IntrusivePtr; + +using ValPtr = IntrusivePtr; +using EnumValPtr = IntrusivePtr; +using TableValPtr = IntrusivePtr; namespace detail { -using ListExprPtr = zeek::IntrusivePtr; +using ListExprPtr = IntrusivePtr; } -} - -namespace zeek { // BRO types. enum TypeTag { @@ -153,18 +151,18 @@ class TypeType; class OpaqueType; class FileType; -using TypePtr = zeek::IntrusivePtr; -using TypeListPtr = zeek::IntrusivePtr; -using TableTypePtr = zeek::IntrusivePtr; -using SetTypePtr = zeek::IntrusivePtr; -using RecordTypePtr = zeek::IntrusivePtr; -using SubNetTypePtr = zeek::IntrusivePtr; -using FuncTypePtr = zeek::IntrusivePtr; -using EnumTypePtr = zeek::IntrusivePtr; -using VectorTypePtr = zeek::IntrusivePtr; -using TypeTypePtr = zeek::IntrusivePtr; -using OpaqueTypePtr = zeek::IntrusivePtr; -using FileTypePtr = zeek::IntrusivePtr; +using TypePtr = IntrusivePtr; +using TypeListPtr = IntrusivePtr; +using TableTypePtr = IntrusivePtr; +using SetTypePtr = IntrusivePtr; +using RecordTypePtr = IntrusivePtr; +using SubNetTypePtr = IntrusivePtr; +using FuncTypePtr = IntrusivePtr; +using EnumTypePtr = IntrusivePtr; +using VectorTypePtr = IntrusivePtr; +using TypeTypePtr = IntrusivePtr; +using OpaqueTypePtr = IntrusivePtr; +using FileTypePtr = IntrusivePtr; constexpr int DOES_NOT_MATCH_INDEX = 0; constexpr int MATCHES_INDEX_SCALAR = 1; @@ -174,7 +172,7 @@ class Type : public Obj { public: static inline const TypePtr nil; - explicit Type(zeek::TypeTag tag, bool base_type = false); + explicit Type(TypeTag tag, bool base_type = false); // Performs a shallow clone operation of the Bro type. // This especially means that especially for tables the types @@ -199,7 +197,7 @@ public: // if it matches and produces a vector result; and // DOES_NOT_MATCH_INDEX = 0 if it can't match (or the type // is not an indexable type). - virtual int MatchesIndex(zeek::detail::ListExpr* index) const; + virtual int MatchesIndex(detail::ListExpr* index) const; // Returns the type yielded by this type. For example, if // this type is a table[string] of port, then returns the "port" @@ -262,7 +260,7 @@ public: return tag == TYPE_TABLE && Yield(); } - Type* Ref() { zeek::Ref(this); return this; } + Type* Ref() { ::zeek::Ref(this); return this; } void Describe(ODesc* d) const override; virtual void DescribeReST(ODesc* d, bool roles_only = false) const; @@ -348,7 +346,7 @@ protected: class IndexType : public Type { public: - int MatchesIndex(zeek::detail::ListExpr* index) const override; + int MatchesIndex(detail::ListExpr* index) const override; const TypeListPtr& GetIndices() const { return indices; } @@ -404,19 +402,19 @@ public: class SetType final : public TableType { public: - SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements); + SetType(TypeListPtr ind, detail::ListExprPtr arg_elements); ~SetType() override; TypePtr ShallowClone() override; [[deprecated("Remove in v4.1. Use Elements() isntead.")]] - zeek::detail::ListExpr* SetElements() const { return elements.get(); } + detail::ListExpr* SetElements() const { return elements.get(); } - const zeek::detail::ListExprPtr& Elements() const + const detail::ListExprPtr& Elements() const { return elements; } protected: - zeek::detail::ListExprPtr elements; + detail::ListExprPtr elements; }; class FuncType final : public Type { @@ -461,7 +459,7 @@ public: void ClearYieldType(FunctionFlavor arg_flav) { yield = nullptr; flavor = arg_flav; } - int MatchesIndex(zeek::detail::ListExpr* index) const override; + int MatchesIndex(detail::ListExpr* index) const override; bool CheckArgs(const TypePList* args, bool is_init = false) const; bool CheckArgs(const std::vector& args, bool is_init = false) const; @@ -492,7 +490,7 @@ public: { return prototypes; } protected: - friend FuncTypePtr zeek::make_intrusive(); + friend FuncTypePtr make_intrusive(); FuncType() : Type(TYPE_FUNC) { flavor = FUNC_FLAVOR_FUNCTION; } RecordTypePtr args; @@ -505,14 +503,14 @@ protected: class TypeType final : public Type { public: explicit TypeType(TypePtr t) : zeek::Type(TYPE_TYPE), type(std::move(t)) {} - TypePtr ShallowClone() override { return zeek::make_intrusive(type); } + TypePtr ShallowClone() override { return make_intrusive(type); } const TypePtr& GetType() const { return type; } template - zeek::IntrusivePtr GetType() const - { return zeek::cast_intrusive(type); } + IntrusivePtr GetType() const + { return cast_intrusive(type); } [[deprecated("Remove in v4.1. Use GetType().")]] zeek::Type* Type() { return type.get(); } @@ -526,21 +524,21 @@ protected: class TypeDecl final { public: TypeDecl() = default; - TypeDecl(const char* i, TypePtr t, zeek::detail::AttributesPtr attrs = nullptr); + TypeDecl(const char* i, TypePtr t, detail::AttributesPtr attrs = nullptr); TypeDecl(const TypeDecl& other); ~TypeDecl(); - const zeek::detail::AttrPtr& GetAttr(zeek::detail::AttrTag a) const - { return attrs ? attrs->Find(a) : zeek::detail::Attr::nil; } + const detail::AttrPtr& GetAttr(detail::AttrTag a) const + { return attrs ? attrs->Find(a) : detail::Attr::nil; } void DescribeReST(ODesc* d, bool roles_only = false) const; TypePtr type; - zeek::detail::AttributesPtr attrs; + detail::AttributesPtr attrs; const char* id = nullptr; }; -using type_decl_list = zeek::PList; +using type_decl_list = PList; class RecordType final : public Type { public: @@ -574,8 +572,8 @@ public: * No check for invalid field name is performed. */ template - zeek::IntrusivePtr GetFieldType(const char* field_name) const - { return zeek::cast_intrusive(GetFieldType(field_name)); } + IntrusivePtr GetFieldType(const char* field_name) const + { return cast_intrusive(GetFieldType(field_name)); } /** * Looks up a field by its index and returns its type. No check for @@ -589,10 +587,10 @@ public: * No check for invalid field offset is performed. */ template - zeek::IntrusivePtr GetFieldType(int field_index) const - { return zeek::cast_intrusive((*types)[field_index]->type); } + IntrusivePtr GetFieldType(int field_index) const + { return cast_intrusive((*types)[field_index]->type); } - zeek::ValPtr FieldDefault(int field) const; + ValPtr FieldDefault(int field) const; // A field's offset is its position in the type_decl_list, // starting at 0. Returns negative if the field doesn't exist. @@ -614,7 +612,7 @@ public: * @param rv an optional record value, if given the values of * all fields will be provided in the returned table. */ - zeek::TableValPtr GetRecordFieldsVal(const zeek::RecordVal* rv = nullptr) const; + TableValPtr GetRecordFieldsVal(const RecordVal* rv = nullptr) const; // Returns null if all is ok, otherwise a pointer to an error message. const char* AddFields(const type_decl_list& types, @@ -628,10 +626,10 @@ public: bool IsFieldDeprecated(int field) const { const TypeDecl* decl = FieldDecl(field); - return decl && decl->GetAttr(zeek::detail::ATTR_DEPRECATED) != nullptr; + return decl && decl->GetAttr(detail::ATTR_DEPRECATED) != nullptr; } - bool FieldHasAttr(int field, zeek::detail::AttrTag at) const + bool FieldHasAttr(int field, detail::AttrTag at) const { const TypeDecl* decl = FieldDecl(field); return decl && decl->GetAttr(at) != nullptr; @@ -655,7 +653,7 @@ public: class FileType final : public Type { public: explicit FileType(TypePtr yield_type); - TypePtr ShallowClone() override { return zeek::make_intrusive(yield); } + TypePtr ShallowClone() override { return make_intrusive(yield); } ~FileType() override; const TypePtr& Yield() const override @@ -670,7 +668,7 @@ protected: class OpaqueType final : public Type { public: explicit OpaqueType(const std::string& name); - TypePtr ShallowClone() override { return zeek::make_intrusive(name); } + TypePtr ShallowClone() override { return make_intrusive(name); } ~OpaqueType() override { }; const std::string& Name() const { return name; } @@ -695,12 +693,12 @@ public: // The value of this name is next internal counter value, starting // with zero. The internal counter is incremented. - void AddName(const std::string& module_name, const char* name, bool is_export, zeek::detail::Expr* deprecation = nullptr); + void AddName(const std::string& module_name, const char* name, bool is_export, detail::Expr* deprecation = nullptr); // The value of this name is set to val. Once a value has been // explicitly assigned using this method, no further names can be // added that aren't likewise explicitly initalized. - void AddName(const std::string& module_name, const char* name, bro_int_t val, bool is_export, zeek::detail::Expr* deprecation = nullptr); + void AddName(const std::string& module_name, const char* name, bro_int_t val, bool is_export, detail::Expr* deprecation = nullptr); // -1 indicates not found. bro_int_t Lookup(const std::string& module_name, const char* name) const; @@ -712,10 +710,10 @@ public: void DescribeReST(ODesc* d, bool roles_only = false) const override; - const zeek::EnumValPtr& GetEnumVal(bro_int_t i); + const EnumValPtr& GetEnumVal(bro_int_t i); [[deprecated("Remove in v4.1. Use GetEnumVal() instead.")]] - zeek::EnumVal* GetVal(bro_int_t i); + EnumVal* GetVal(bro_int_t i); protected: void AddNameInternal(const std::string& module_name, @@ -723,12 +721,12 @@ protected: void CheckAndAddName(const std::string& module_name, const char* name, bro_int_t val, bool is_export, - zeek::detail::Expr* deprecation = nullptr); + detail::Expr* deprecation = nullptr); typedef std::map NameMap; NameMap names; - using ValMap = std::unordered_map; + using ValMap = std::unordered_map; ValMap vals; // The counter is initialized to 0 and incremented on every implicit @@ -748,7 +746,7 @@ public: const TypePtr& Yield() const override; - int MatchesIndex(zeek::detail::ListExpr* index) const override; + int MatchesIndex(detail::ListExpr* index) const override; // Returns true if this table type is "unspecified", which is what one // gets using an empty "vector()" constructor. @@ -780,7 +778,7 @@ inline bool same_type(const Type* t1, const TypePtr& t2, { return same_type(*t1, *t2, is_init, match_record_field_names); } // True if the two attribute lists are equivalent. -extern bool same_attrs(const zeek::detail::Attributes* a1, const zeek::detail::Attributes* a2); +extern bool same_attrs(const detail::Attributes* a1, const detail::Attributes* a2); // Returns true if the record sub_rec can be promoted to the record // super_rec. @@ -803,10 +801,10 @@ TypePtr merge_types(const TypePtr& t1, const TypePtr& t2); // Given a list of expressions, returns a (ref'd) type reflecting // a merged type consistent across all of them, or nil if this // cannot be done. -TypePtr merge_type_list(zeek::detail::ListExpr* elements); +TypePtr merge_type_list(detail::ListExpr* elements); // Given an expression, infer its type when used for an initialization. -TypePtr init_type(zeek::detail::Expr* init); +TypePtr init_type(detail::Expr* init); // Returns true if argument is an atomic type. bool is_atomic_type(const Type& t); @@ -818,7 +816,7 @@ inline bool is_atomic_type(const TypePtr& t) // True if the given type tag corresponds to type that can be assigned to. extern bool is_assignable(TypeTag t); inline bool is_assignable(Type* t) - { return zeek::is_assignable(t->Tag()); } + { return is_assignable(t->Tag()); } // True if the given type tag corresponds to an integral type. inline bool IsIntegral(TypeTag t) { return (t == TYPE_INT || t == TYPE_COUNT ); } @@ -869,7 +867,7 @@ inline bool BothString(TypeTag t1, TypeTag t2) { return (IsString(t1) && IsStrin inline bool EitherError(TypeTag t1, TypeTag t2) { return (IsErrorType(t1) || IsErrorType(t2)); } // Returns the basic (non-parameterized) type with the given type. -const TypePtr& base_type(zeek::TypeTag tag); +const TypePtr& base_type(TypeTag tag); // Returns the basic error type. inline const TypePtr& error_type() { return base_type(TYPE_ERROR); } diff --git a/src/UID.cc b/src/UID.cc index fe2de22de9..4184506fc7 100644 --- a/src/UID.cc +++ b/src/UID.cc @@ -24,7 +24,7 @@ void UID::Set(bro_uint_t bits, const uint64_t* v, size_t n) size_t size = res.rem ? res.quot + 1 : res.quot; for ( size_t i = 0; i < size; ++i ) - uid[i] = v && i < n ? v[i] : zeek::util::calculate_unique_id(); + uid[i] = v && i < n ? v[i] : util::calculate_unique_id(); if ( res.rem ) uid[0] >>= 64 - res.rem; @@ -33,11 +33,11 @@ void UID::Set(bro_uint_t bits, const uint64_t* v, size_t n) std::string UID::Base62(std::string prefix) const { if ( ! initialized ) - zeek::reporter->InternalError("use of uninitialized UID"); + reporter->InternalError("use of uninitialized UID"); char tmp[sizeof(uid) * 8 + 1]; // enough for even binary representation for ( size_t i = 0; i < BRO_UID_LEN; ++i ) - prefix.append(zeek::util::uitoa_n(uid[i], tmp, sizeof(tmp), 62)); + prefix.append(util::uitoa_n(uid[i], tmp, sizeof(tmp), 62)); return prefix; } diff --git a/src/Val.cc b/src/Val.cc index 7f7849bcb5..cdd5351eb7 100644 --- a/src/Val.cc +++ b/src/Val.cc @@ -46,10 +46,10 @@ using namespace std; namespace zeek { -Val::Val(zeek::Func* f) : Val({NewRef{}, f}) +Val::Val(Func* f) : Val({NewRef{}, f}) {} -Val::Val(zeek::FuncPtr f) +Val::Val(FuncPtr f) : val(f.release()), type(val.func_val->GetType()) {} @@ -61,10 +61,10 @@ static const FileTypePtr& GetStringFileType() noexcept return string_file_type; } -Val::Val(zeek::File* f) : Val({AdoptRef{}, f}) +Val::Val(File* f) : Val({AdoptRef{}, f}) {} -Val::Val(zeek::FilePtr f) +Val::Val(FilePtr f) : val(f.release()), type(GetStringFileType()) { assert(val.file_val->GetType()->Tag() == TYPE_STRING); @@ -89,14 +89,14 @@ Val::~Val() #define CONVERTER(tag, ctype, name) \ ctype name() \ { \ - CHECK_TAG(type->Tag(), tag, "Val::CONVERTER", zeek::type_name) \ + CHECK_TAG(type->Tag(), tag, "Val::CONVERTER", type_name) \ return (ctype)(this); \ } #define CONST_CONVERTER(tag, ctype, name) \ const ctype name() const \ { \ - CHECK_TAG(type->Tag(), tag, "Val::CONVERTER", zeek::type_name) \ + CHECK_TAG(type->Tag(), tag, "Val::CONVERTER", type_name) \ return (const ctype)(this); \ } @@ -104,17 +104,17 @@ Val::~Val() CONVERTER(tag, ctype, name) \ CONST_CONVERTER(tag, ctype, name) -CONVERTERS(zeek::TYPE_PATTERN, PatternVal*, Val::AsPatternVal) -CONVERTERS(zeek::TYPE_PORT, PortVal*, Val::AsPortVal) -CONVERTERS(zeek::TYPE_SUBNET, SubNetVal*, Val::AsSubNetVal) -CONVERTERS(zeek::TYPE_ADDR, AddrVal*, Val::AsAddrVal) -CONVERTERS(zeek::TYPE_TABLE, TableVal*, Val::AsTableVal) -CONVERTERS(zeek::TYPE_RECORD, RecordVal*, Val::AsRecordVal) -CONVERTERS(zeek::TYPE_LIST, ListVal*, Val::AsListVal) -CONVERTERS(zeek::TYPE_STRING, StringVal*, Val::AsStringVal) -CONVERTERS(zeek::TYPE_VECTOR, VectorVal*, Val::AsVectorVal) -CONVERTERS(zeek::TYPE_ENUM, EnumVal*, Val::AsEnumVal) -CONVERTERS(zeek::TYPE_OPAQUE, OpaqueVal*, Val::AsOpaqueVal) +CONVERTERS(TYPE_PATTERN, PatternVal*, Val::AsPatternVal) +CONVERTERS(TYPE_PORT, PortVal*, Val::AsPortVal) +CONVERTERS(TYPE_SUBNET, SubNetVal*, Val::AsSubNetVal) +CONVERTERS(TYPE_ADDR, AddrVal*, Val::AsAddrVal) +CONVERTERS(TYPE_TABLE, TableVal*, Val::AsTableVal) +CONVERTERS(TYPE_RECORD, RecordVal*, Val::AsRecordVal) +CONVERTERS(TYPE_LIST, ListVal*, Val::AsListVal) +CONVERTERS(TYPE_STRING, StringVal*, Val::AsStringVal) +CONVERTERS(TYPE_VECTOR, VectorVal*, Val::AsVectorVal) +CONVERTERS(TYPE_ENUM, EnumVal*, Val::AsEnumVal) +CONVERTERS(TYPE_OPAQUE, OpaqueVal*, Val::AsOpaqueVal) ValPtr Val::CloneState::NewClone(Val* src, ValPtr dst) { @@ -156,7 +156,7 @@ ValPtr Val::DoClone(CloneState* state) // Derived classes are responsible for this. Exception: // Functions and files. There aren't any derived classes. if ( type->Tag() == TYPE_FUNC ) - return make_intrusive(AsFunc()->DoClone()); + return make_intrusive(AsFunc()->DoClone()); if ( type->Tag() == TYPE_FILE ) { @@ -187,7 +187,7 @@ ValPtr Val::DoClone(CloneState* state) return nullptr; } -zeek::FuncPtr Val::AsFuncPtr() const +FuncPtr Val::AsFuncPtr() const { CHECK_TAG(type->Tag(), TYPE_FUNC, "Val::Func", type_name) return {NewRef{}, val.func_val}; @@ -297,29 +297,29 @@ ValPtr Val::SizeVal() const // Return abs value. However abs() only works on ints and llabs // doesn't work on Mac OS X 10.5. So we do it by hand if ( val.int_val < 0 ) - return zeek::val_mgr->Count(-val.int_val); + return val_mgr->Count(-val.int_val); else - return zeek::val_mgr->Count(val.int_val); + return val_mgr->Count(val.int_val); case TYPE_INTERNAL_UNSIGNED: - return zeek::val_mgr->Count(val.uint_val); + return val_mgr->Count(val.uint_val); case TYPE_INTERNAL_DOUBLE: - return make_intrusive(fabs(val.double_val)); + return make_intrusive(fabs(val.double_val)); case TYPE_INTERNAL_OTHER: if ( type->Tag() == TYPE_FUNC ) - return zeek::val_mgr->Count(val.func_val->GetType()->ParamList()->GetTypes().size()); + return val_mgr->Count(val.func_val->GetType()->ParamList()->GetTypes().size()); if ( type->Tag() == TYPE_FILE ) - return make_intrusive(val.file_val->Size()); + return make_intrusive(val.file_val->Size()); break; default: break; } - return zeek::val_mgr->Count(0); + return val_mgr->Count(0); } unsigned int Val::MemoryAllocation() const @@ -415,17 +415,17 @@ void Val::ValDescribeReST(ODesc* d) const #ifdef DEBUG detail::ID* Val::GetID() const { - return bound_id ? zeek::detail::global_scope()->Find(bound_id).get() : nullptr; + return bound_id ? detail::global_scope()->Find(bound_id).get() : nullptr; } void Val::SetID(detail::ID* id) { delete [] bound_id; - bound_id = id ? zeek::util::copy_string(id->Name()) : nullptr; + bound_id = id ? util::copy_string(id->Name()) : nullptr; } #endif -bool Val::WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val) + bool Val::WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val) { if ( !to_type || !from_type ) return true; @@ -461,7 +461,7 @@ TableValPtr Val::GetRecordFields() if ( t->Tag() != TYPE_RECORD && t->Tag() != TYPE_TYPE ) { reporter->Error("non-record value/type passed to record_fields"); - return make_intrusive(record_field_table); + return make_intrusive(record_field_table); } RecordType* rt = nullptr; @@ -479,7 +479,7 @@ TableValPtr Val::GetRecordFields() if ( t->Tag() != TYPE_RECORD ) { reporter->Error("non-record value/type passed to record_fields"); - return make_intrusive(record_field_table); + return make_intrusive(record_field_table); } rt = t->AsRecordType(); @@ -489,7 +489,7 @@ TableValPtr Val::GetRecordFields() } // This is a static method in this file to avoid including rapidjson's headers in Val.h because they're huge. -static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer, Val* val, +static void BuildJSON(threading::formatter::JSON::NullDoubleWriter& writer, Val* val, bool only_loggable=false, RE_Matcher* re=nullptr, const string& key="") { if ( !key.empty() ) @@ -558,7 +558,7 @@ static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer ODesc d; d.SetStyle(RAW_STYLE); val->Describe(&d); - writer.String(zeek::util::json_escape_utf8(std::string(reinterpret_cast(d.Bytes()), d.Len()))); + writer.String(util::json_escape_utf8(std::string(reinterpret_cast(d.Bytes()), d.Len()))); break; } @@ -572,7 +572,7 @@ static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer else writer.StartObject(); - zeek::detail::HashKey* k; + detail::HashKey* k; TableEntryVal* entry; auto c = table->InitForIteration(); while ( (entry = table->NextEntry(k, c)) ) @@ -586,7 +586,7 @@ static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer else { rapidjson::StringBuffer buffer; - zeek::threading::formatter::JSON::NullDoubleWriter key_writer(buffer); + threading::formatter::JSON::NullDoubleWriter key_writer(buffer); BuildJSON(key_writer, entry_key, only_loggable, re); string key_str = buffer.GetString(); @@ -626,8 +626,8 @@ static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer if ( re && re->MatchAnywhere(field_name) != 0 ) { - auto blank = make_intrusive(""); - auto fn_val = make_intrusive(field_name); + auto blank = make_intrusive(""); + auto fn_val = make_intrusive(field_name); const auto& bs = *blank->AsString(); auto key_val = fn_val->Replace(re, bs, false); key_str = key_val->ToStdString(); @@ -690,11 +690,11 @@ static void BuildJSON(zeek::threading::formatter::JSON::NullDoubleWriter& writer StringValPtr Val::ToJSON(bool only_loggable, RE_Matcher* re) { rapidjson::StringBuffer buffer; - zeek::threading::formatter::JSON::NullDoubleWriter writer(buffer); + threading::formatter::JSON::NullDoubleWriter writer(buffer); BuildJSON(writer, this, only_loggable, re, ""); - return make_intrusive(buffer.GetString()); + return make_intrusive(buffer.GetString()); } void IntervalVal::ValDescribe(ODesc* d) const @@ -772,7 +772,7 @@ void IntervalVal::ValDescribe(ODesc* d) const ValPtr PortVal::SizeVal() const { - return zeek::val_mgr->Int(val.uint_val); + return val_mgr->Int(val.uint_val); } uint32_t PortVal::Mask(uint32_t port_num, TransportProto port_type) @@ -891,9 +891,9 @@ unsigned int AddrVal::MemoryAllocation() const ValPtr AddrVal::SizeVal() const { if ( val.addr_val->GetFamily() == IPv4 ) - return zeek::val_mgr->Count(32); + return val_mgr->Count(32); else - return zeek::val_mgr->Count(128); + return val_mgr->Count(128); } ValPtr AddrVal::DoClone(CloneState* state) @@ -951,7 +951,7 @@ unsigned int SubNetVal::MemoryAllocation() const ValPtr SubNetVal::SizeVal() const { int retained = 128 - val.subnet_val->LengthIPv6(); - return make_intrusive(pow(2.0, double(retained))); + return make_intrusive(pow(2.0, double(retained))); } void SubNetVal::ValDescribe(ODesc* d) const @@ -1019,7 +1019,7 @@ StringVal::StringVal(const string& s) : StringVal(s.length(), s.data()) ValPtr StringVal::SizeVal() const { - return zeek::val_mgr->Count(val.string_val->Len()); + return val_mgr->Count(val.string_val->Len()); } int StringVal::Len() @@ -1146,7 +1146,7 @@ StringValPtr StringVal::Replace( // the NUL. r[0] = '\0'; - return make_intrusive(new String(true, result, r - result)); + return make_intrusive(new String(true, result, r - result)); } ValPtr StringVal::DoClone(CloneState* state) @@ -1154,7 +1154,7 @@ ValPtr StringVal::DoClone(CloneState* state) // We could likely treat this type as immutable and return a reference // instead of creating a new copy, but we first need to be careful and // audit whether anything internal actually does mutate it. - return state->NewClone(this, make_intrusive( + return state->NewClone(this, make_intrusive( new String((u_char*) val.string_val->Bytes(), val.string_val->Len(), true))); } @@ -1215,7 +1215,7 @@ ValPtr PatternVal::DoClone(CloneState* state) auto re = new RE_Matcher(val.re_val->PatternText(), val.re_val->AnywherePatternText()); re->Compile(); - return state->NewClone(this, make_intrusive(re)); + return state->NewClone(this, make_intrusive(re)); } ListVal::ListVal(TypeTag t) @@ -1230,7 +1230,7 @@ ListVal::~ListVal() ValPtr ListVal::SizeVal() const { - return zeek::val_mgr->Count(vals.size()); + return val_mgr->Count(vals.size()); } RE_Matcher* ListVal::BuildRE() const @@ -1275,7 +1275,7 @@ TableValPtr ListVal::ToSetVal() const auto set_index = make_intrusive(pt); set_index->Append(base_type(tag)); auto s = make_intrusive(std::move(set_index), nullptr); - auto t = make_intrusive(std::move(s)); + auto t = make_intrusive(std::move(s)); for ( const auto& val : vals ) t->Assign(val, nullptr); @@ -1315,7 +1315,7 @@ void ListVal::Describe(ODesc* d) const ValPtr ListVal::DoClone(CloneState* state) { - auto lv = make_intrusive(tag); + auto lv = make_intrusive(tag); lv->vals.reserve(vals.size()); state->NewClone(this, lv); @@ -1331,7 +1331,7 @@ unsigned int ListVal::MemoryAllocation() const for ( const auto& val : vals ) size += val->MemoryAllocation(); - size += zeek::util::pad_size(vals.capacity() * sizeof(decltype(vals)::value_type)); + size += util::pad_size(vals.capacity() * sizeof(decltype(vals)::value_type)); return size + padded_sizeof(*this) + type->MemoryAllocation(); } @@ -1342,7 +1342,7 @@ TableEntryVal* TableEntryVal::Clone(Val::CloneState* state) return rval; } -TableValTimer::TableValTimer(TableVal* val, double t) : zeek::detail::Timer(t, zeek::detail::TIMER_TABLE_VAL) +TableValTimer::TableValTimer(TableVal* val, double t) : detail::Timer(t, detail::TIMER_TABLE_VAL) { table = val; } @@ -1412,7 +1412,7 @@ TableVal::TableVal(TableTypePtr t, detail::AttributesPtr a) : Val(t) Init(std::move(t)); SetAttrs(std::move(a)); - if ( ! zeek::run_state::is_parsing ) + if ( ! run_state::is_parsing ) return; for ( const auto& t : table_type->GetIndexTypes() ) @@ -1437,19 +1437,19 @@ void TableVal::Init(TableTypePtr t) def_val = nullptr; if ( table_type->IsSubNetIndex() ) - subnets = new zeek::detail::PrefixTable; + subnets = new detail::PrefixTable; else subnets = nullptr; - table_hash = new zeek::detail::CompositeHash(table_type->GetIndices()); - val.table_val = new PDict; + table_hash = new detail::CompositeHash(table_type->GetIndices()); + val.table_val = new PDict; val.table_val->SetDeleteFunc(table_entry_val_delete_func); } TableVal::~TableVal() { if ( timer ) - zeek::detail::timer_mgr->Cancel(timer); + detail::timer_mgr->Cancel(timer); delete table_hash; delete AsTable(); @@ -1460,7 +1460,7 @@ void TableVal::RemoveAll() { // Here we take the brute force approach. delete AsTable(); - val.table_val = new PDict; + val.table_val = new PDict; val.table_val->SetDeleteFunc(table_entry_val_delete_func); } @@ -1477,7 +1477,7 @@ int TableVal::RecursiveSize() const GetType()->AsTableType()->Yield()->Tag() != TYPE_TABLE ) return n; - PDict* v = val.table_val; + PDict* v = val.table_val; IterCookie* c = v->InitForIteration(); TableEntryVal* tv; @@ -1511,12 +1511,12 @@ void TableVal::SetAttrs(detail::AttributesPtr a) if ( cf ) change_func = cf->GetExpr(); - auto bs = attrs->Find(zeek::detail::ATTR_BROKER_STORE); + auto bs = attrs->Find(detail::ATTR_BROKER_STORE); if ( bs && broker_store.empty() ) { auto c = bs->GetExpr()->Eval(nullptr); assert(c); - assert(c->GetType()->Tag() == zeek::TYPE_STRING); + assert(c->GetType()->Tag() == TYPE_STRING); broker_store = c->AsStringVal()->AsString()->CheckString(); broker_mgr->AddForwardedStore(broker_store, {NewRef{}, this}); } @@ -1539,12 +1539,12 @@ void TableVal::CheckExpireAttr(detail::AttrTag at) } if ( timer ) - zeek::detail::timer_mgr->Cancel(timer); + detail::timer_mgr->Cancel(timer); // As network_time is not necessarily initialized yet, // we set a timer which fires immediately. timer = new TableValTimer(this, 1); - zeek::detail::timer_mgr->Add(timer); + detail::timer_mgr->Add(timer); } } @@ -1566,7 +1566,7 @@ bool TableVal::Assign(Val* index, Val* new_val) return Assign({NewRef{}, index}, {AdoptRef{}, new_val}); } -bool TableVal::Assign(ValPtr index, std::unique_ptr k, +bool TableVal::Assign(ValPtr index, std::unique_ptr k, ValPtr new_val, bool broker_forward) { bool is_set = table_type->IsSet(); @@ -1575,7 +1575,7 @@ bool TableVal::Assign(ValPtr index, std::unique_ptr k, InternalWarning("bad set/table in TableVal::Assign"); TableEntryVal* new_entry_val = new TableEntryVal(std::move(new_val)); - zeek::detail::HashKey k_copy(k->Key(), k->Size(), k->Hash()); + detail::HashKey k_copy(k->Key(), k->Size(), k->Hash()); TableEntryVal* old_entry_val = AsNonConstTable()->Insert(k.get(), new_entry_val); // If the dictionary index already existed, the insert may free up the @@ -1620,14 +1620,14 @@ bool TableVal::Assign(ValPtr index, std::unique_ptr k, return true; } -bool TableVal::Assign(Val* index, zeek::detail::HashKey* k, Val* new_val) +bool TableVal::Assign(Val* index, detail::HashKey* k, Val* new_val) { - return Assign({NewRef{}, index}, std::unique_ptr{k}, {AdoptRef{}, new_val}); + return Assign({NewRef{}, index}, std::unique_ptr{k}, {AdoptRef{}, new_val}); } ValPtr TableVal::SizeVal() const { - return zeek::val_mgr->Count(Size()); + return val_mgr->Count(Size()); } bool TableVal::AddTo(Val* val, bool is_first_init) const @@ -1651,14 +1651,14 @@ bool TableVal::AddTo(Val* val, bool is_first_init, bool propagate_ops) const return false; } - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); IterCookie* c = tbl->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; TableEntryVal* v; while ( (v = tbl->NextEntry(k, c)) ) { - std::unique_ptr hk{k}; + std::unique_ptr hk{k}; if ( is_first_init && t->AsTable()->Lookup(k) ) { @@ -1699,10 +1699,10 @@ bool TableVal::RemoveFrom(Val* val) const return false; } - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); IterCookie* c = tbl->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; while ( tbl->NextEntry(k, c) ) { // Not sure that this is 100% sound, since the HashKey @@ -1719,22 +1719,22 @@ bool TableVal::RemoveFrom(Val* val) const TableValPtr TableVal::Intersection(const TableVal& tv) const { - auto result = make_intrusive(table_type); + auto result = make_intrusive(table_type); - const PDict* t0 = AsTable(); - const PDict* t1 = tv.AsTable(); - PDict* t2 = result->AsNonConstTable(); + const PDict* t0 = AsTable(); + const PDict* t1 = tv.AsTable(); + PDict* t2 = result->AsNonConstTable(); // Figure out which is smaller; assign it to t1. if ( t1->Length() > t0->Length() ) { // Swap. - const PDict* tmp = t1; + const PDict* tmp = t1; t1 = t0; t0 = tmp; } IterCookie* c = t1->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; while ( t1->NextEntry(k, c) ) { // Here we leverage the same assumption about consistent @@ -1750,14 +1750,14 @@ TableValPtr TableVal::Intersection(const TableVal& tv) const bool TableVal::EqualTo(const TableVal& tv) const { - const PDict* t0 = AsTable(); - const PDict* t1 = tv.AsTable(); + const PDict* t0 = AsTable(); + const PDict* t1 = tv.AsTable(); if ( t0->Length() != t1->Length() ) return false; IterCookie* c = t0->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; while ( t0->NextEntry(k, c) ) { // Here we leverage the same assumption about consistent @@ -1777,14 +1777,14 @@ bool TableVal::EqualTo(const TableVal& tv) const bool TableVal::IsSubsetOf(const TableVal& tv) const { - const PDict* t0 = AsTable(); - const PDict* t1 = tv.AsTable(); + const PDict* t0 = AsTable(); + const PDict* t1 = tv.AsTable(); if ( t0->Length() > t1->Length() ) return false; IterCookie* c = t0->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; while ( t0->NextEntry(k, c) ) { // Here we leverage the same assumption about consistent @@ -1905,7 +1905,7 @@ ValPtr TableVal::Default(const ValPtr& index) return nullptr; } - const zeek::Func* f = def_val->AsFunc(); + const Func* f = def_val->AsFunc(); Args vl; if ( index->GetType()->Tag() == TYPE_LIST ) @@ -1951,13 +1951,13 @@ const ValPtr& TableVal::Find(const ValPtr& index) if ( v->GetVal() ) return v->GetVal(); - return zeek::val_mgr->True(); + return val_mgr->True(); } return Val::nil; } - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); if ( tbl->Length() > 0 ) { @@ -1975,7 +1975,7 @@ const ValPtr& TableVal::Find(const ValPtr& index) if ( v->GetVal() ) return v->GetVal(); - return zeek::val_mgr->True(); + return val_mgr->True(); } } } @@ -2012,11 +2012,11 @@ VectorValPtr TableVal::LookupSubnets(const SubNetVal* search) if ( ! subnets ) reporter->InternalError("LookupSubnets called on wrong table type"); - auto result = make_intrusive(id::find_type("subnet_vec")); + auto result = make_intrusive(id::find_type("subnet_vec")); auto matches = subnets->FindAll(search); for ( auto element : matches ) - result->Assign(result->Size(), make_intrusive(get<0>(element))); + result->Assign(result->Size(), make_intrusive(get<0>(element))); return result; } @@ -2026,12 +2026,12 @@ TableValPtr TableVal::LookupSubnetValues(const SubNetVal* search) if ( ! subnets ) reporter->InternalError("LookupSubnetValues called on wrong table type"); - auto nt = make_intrusive(this->GetType()); + auto nt = make_intrusive(this->GetType()); auto matches = subnets->FindAll(search); for ( auto element : matches ) { - auto s = make_intrusive(get<0>(element)); + auto s = make_intrusive(get<0>(element)); TableEntryVal* entry = reinterpret_cast(get<1>(element)); if ( entry && entry->GetVal() ) @@ -2073,7 +2073,7 @@ bool TableVal::UpdateTimestamp(Val* index) return true; } -ListValPtr TableVal::RecreateIndex(const zeek::detail::HashKey& k) const +ListValPtr TableVal::RecreateIndex(const detail::HashKey& k) const { return table_hash->RecoverVals(k); } @@ -2101,11 +2101,11 @@ void TableVal::CallChangeFunc(const ValPtr& index, return; } - const zeek::Func* f = thefunc->AsFunc(); - zeek::Args vl; + const Func* f = thefunc->AsFunc(); + Args vl; // we either get passed the raw index_val - or a ListVal with exactly one element. - if ( index->GetType()->Tag() == zeek::TYPE_LIST ) + if ( index->GetType()->Tag() == TYPE_LIST ) vl.reserve(2 + index->AsListVal()->Length() + table_type->IsTable()); else vl.reserve(3 + table_type->IsTable()); @@ -2128,7 +2128,7 @@ void TableVal::CallChangeFunc(const ValPtr& index, } - if ( index->GetType()->Tag() == zeek::TYPE_LIST ) + if ( index->GetType()->Tag() == TYPE_LIST ) { for ( const auto& v : index->AsListVal()->Vals() ) vl.emplace_back(v); @@ -2164,11 +2164,11 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, // we either get passed the raw index_val - or a ListVal with exactly one element. // Since Broker does not support ListVals, we have to unoll this in the second case. const Val* index_val; - if ( index->GetType()->Tag() == zeek::TYPE_LIST ) + if ( index->GetType()->Tag() == TYPE_LIST ) { if ( index->AsListVal()->Length() != 1 ) { - zeek::emit_builtin_error("table with complex index not supported for &broker_store"); + emit_builtin_error("table with complex index not supported for &broker_store"); return; } @@ -2179,11 +2179,11 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, index_val = index; } - auto broker_index = zeek::Broker::detail::val_to_data(index_val); + auto broker_index = Broker::detail::val_to_data(index_val); if ( ! broker_index ) { - zeek::emit_builtin_error("invalid Broker data conversation for table index"); + emit_builtin_error("invalid Broker data conversation for table index"); return; } @@ -2201,7 +2201,7 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, if ( expire_time > 0 ) { - if ( attrs->Find(zeek::detail::ATTR_EXPIRE_CREATE) ) + if ( attrs->Find(detail::ATTR_EXPIRE_CREATE) ) { // for create expiry, we have to substract the already elapsed time from the expiry. auto e = expire_time - (run_state::network_time - new_entry_val->ExpireAccessTime()); @@ -2209,10 +2209,10 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, // element already expired? Let's not insert it. break; - expiry = zeek::Broker::detail::convert_expiry(e); + expiry = Broker::detail::convert_expiry(e); } else - expiry = zeek::Broker::detail::convert_expiry(expire_time); + expiry = Broker::detail::convert_expiry(expire_time); } if ( table_type->IsSet() ) @@ -2221,15 +2221,15 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, { if ( ! new_entry_val ) { - zeek::emit_builtin_error("did not receive new value for Broker datastore send operation"); + emit_builtin_error("did not receive new value for Broker datastore send operation"); return; } auto new_value = new_entry_val->GetVal().get(); - auto broker_val = zeek::Broker::detail::val_to_data(new_value); + auto broker_val = Broker::detail::val_to_data(new_value); if ( ! broker_val ) { - zeek::emit_builtin_error("invalid Broker data conversation for table value"); + emit_builtin_error("invalid Broker data conversation for table value"); return; } @@ -2250,7 +2250,7 @@ void TableVal::SendToStore(const Val* index, const TableEntryVal* new_entry_val, } catch ( InterpreterException& e ) { - zeek::emit_builtin_error("The previous error was encountered while trying to resolve the &broker_store attribute of the set/table. Potentially the Broker::Store has not been initialized before being used."); + emit_builtin_error("The previous error was encountered while trying to resolve the &broker_store attribute of the set/table. Potentially the Broker::Store has not been initialized before being used."); } } @@ -2284,7 +2284,7 @@ ValPtr TableVal::Remove(const Val& index, bool broker_forward) return va; } -ValPtr TableVal::Remove(const zeek::detail::HashKey& k) +ValPtr TableVal::Remove(const detail::HashKey& k) { TableEntryVal* v = AsNonConstTable()->RemoveEntry(k); ValPtr va; @@ -2319,12 +2319,12 @@ ValPtr TableVal::Remove(const zeek::detail::HashKey& k) ListValPtr TableVal::ToListVal(TypeTag t) const { - auto l = make_intrusive(t); + auto l = make_intrusive(t); - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); IterCookie* c = tbl->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; while ( tbl->NextEntry(k, c) ) { auto index = table_hash->RecoverVals(*k); @@ -2375,7 +2375,7 @@ const detail::AttrPtr& TableVal::GetAttr(detail::AttrTag t) const void TableVal::Describe(ODesc* d) const { - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); int n = tbl->Length(); if ( d->IsBinary() || d->IsPortable() ) @@ -2396,7 +2396,7 @@ void TableVal::Describe(ODesc* d) const for ( int i = 0; i < n; ++i ) { - zeek::detail::HashKey* k; + detail::HashKey* k; TableEntryVal* v = tbl->NextEntry(k, c); if ( ! v ) @@ -2445,7 +2445,7 @@ void TableVal::Describe(ODesc* d) const if ( d->IsReadable() && ! d->IsShort() && d->IncludeStats() ) { d->Add(" @"); - d->Add(zeek::util::detail::fmt_access_time(v->ExpireAccessTime())); + d->Add(util::detail::fmt_access_time(v->ExpireAccessTime())); } } @@ -2469,7 +2469,7 @@ bool TableVal::ExpandCompoundAndInit(ListVal* lv, int k, ValPtr new_val) for ( int i = 0; i < ind_k->Length(); ++i ) { const auto& ind_k_i = ind_k->Idx(i); - auto expd = make_intrusive(TYPE_ANY); + auto expd = make_intrusive(TYPE_ANY); for ( auto j = 0; j < lv->Length(); ++j ) { @@ -2503,7 +2503,7 @@ bool TableVal::CheckAndAssign(ValPtr index, ValPtr new_val) return Assign(std::move(index), std::move(new_val)); } -void TableVal::InitDefaultFunc(zeek::detail::Frame* f) +void TableVal::InitDefaultFunc(detail::Frame* f) { // Value aready initialized. if ( def_val ) @@ -2529,7 +2529,7 @@ void TableVal::InitDefaultFunc(zeek::detail::Frame* f) void TableVal::InitTimer(double delay) { timer = new TableValTimer(this, run_state::network_time + delay); - zeek::detail::timer_mgr->Add(timer); + detail::timer_mgr->Add(timer); } void TableVal::DoExpire(double t) @@ -2537,7 +2537,7 @@ void TableVal::DoExpire(double t) if ( ! type ) return; // FIX ME ### - PDict* tbl = AsNonConstTable(); + PDict* tbl = AsNonConstTable(); double timeout = GetExpireTime(); @@ -2552,7 +2552,7 @@ void TableVal::DoExpire(double t) tbl->MakeRobustCookie(expire_cookie); } - zeek::detail::HashKey* k = nullptr; + detail::HashKey* k = nullptr; TableEntryVal* v = nullptr; TableEntryVal* v_saved = nullptr; bool modified = false; @@ -2661,7 +2661,7 @@ double TableVal::GetExpireTime() expire_time = nullptr; if ( timer ) - zeek::detail::timer_mgr->Cancel(timer); + detail::timer_mgr->Cancel(timer); return -1; } @@ -2687,7 +2687,7 @@ double TableVal::CallExpireFunc(ListValPtr idx) return 0; } - const zeek::Func* f = vf->AsFunc(); + const Func* f = vf->AsFunc(); Args vl; const auto& func_args = f->GetType()->ParamList()->GetTypes(); @@ -2731,13 +2731,13 @@ double TableVal::CallExpireFunc(ListValPtr idx) ValPtr TableVal::DoClone(CloneState* state) { - auto tv = make_intrusive(table_type); + auto tv = make_intrusive(table_type); state->NewClone(this, tv); - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); IterCookie* cookie = tbl->InitForIteration(); - zeek::detail::HashKey* key; + detail::HashKey* key; TableEntryVal* val; while ( (val = tbl->NextEntry(key, cookie)) ) { @@ -2762,7 +2762,7 @@ ValPtr TableVal::DoClone(CloneState* state) // As network_time is not necessarily initialized yet, we set // a timer which fires immediately. timer = new TableValTimer(this, 1); - zeek::detail::timer_mgr->Add(timer); + detail::timer_mgr->Add(timer); } if ( expire_func ) @@ -2778,7 +2778,7 @@ unsigned int TableVal::MemoryAllocation() const { unsigned int size = 0; - PDict* v = val.table_val; + PDict* v = val.table_val; IterCookie* c = v->InitForIteration(); TableEntryVal* tv; @@ -2793,10 +2793,10 @@ unsigned int TableVal::MemoryAllocation() const + table_hash->MemoryAllocation(); } -zeek::detail::HashKey* TableVal::ComputeHash(const Val* index) const +detail::HashKey* TableVal::ComputeHash(const Val* index) const { return MakeHashKey(*index).release(); } -std::unique_ptr TableVal::MakeHashKey(const Val& index) const +std::unique_ptr TableVal::MakeHashKey(const Val& index) const { return table_hash->MakeHashKey(index, true); } @@ -2829,10 +2829,10 @@ void TableVal::DoneParsing() TableVal::ParseTimeTableState TableVal::DumpTableState() { - const PDict* tbl = AsTable(); + const PDict* tbl = AsTable(); IterCookie* cookie = tbl->InitForIteration(); - zeek::detail::HashKey* key; + detail::HashKey* key; TableEntryVal* val; ParseTimeTableState rval; @@ -2850,7 +2850,7 @@ TableVal::ParseTimeTableState TableVal::DumpTableState() void TableVal::RebuildTable(ParseTimeTableState ptts) { delete table_hash; - table_hash = new zeek::detail::CompositeHash(table_type->GetIndices()); + table_hash = new detail::CompositeHash(table_type->GetIndices()); for ( auto& [key, val] : ptts ) Assign(std::move(key), std::move(val)); @@ -2874,7 +2874,7 @@ RecordVal::RecordVal(RecordTypePtr t, bool init_fields) : Val(std::move(t)) auto vl = val.record_val = new std::vector; vl->reserve(n); - if ( zeek::run_state::is_parsing ) + if ( run_state::is_parsing ) parse_time_records[rt].emplace_back(NewRef{}, this); if ( ! init_fields ) @@ -2904,14 +2904,14 @@ RecordVal::RecordVal(RecordTypePtr t, bool init_fields) : Val(std::move(t)) TypeTag tag = type->Tag(); if ( tag == TYPE_RECORD ) - def = make_intrusive(cast_intrusive(type)); + def = make_intrusive(cast_intrusive(type)); else if ( tag == TYPE_TABLE ) - def = make_intrusive(IntrusivePtr{NewRef{}, type->AsTableType()}, + def = make_intrusive(IntrusivePtr{NewRef{}, type->AsTableType()}, IntrusivePtr{NewRef{}, a}); else if ( tag == TYPE_VECTOR ) - def = make_intrusive(cast_intrusive(type)); + def = make_intrusive(cast_intrusive(type)); } vl->emplace_back(std::move(def)); @@ -2925,7 +2925,7 @@ RecordVal::~RecordVal() ValPtr RecordVal::SizeVal() const { - return zeek::val_mgr->Count(GetType()->AsRecordType()->NumFields()); + return val_mgr->Count(GetType()->AsRecordType()->NumFields()); } void RecordVal::Assign(int field, ValPtr new_val) @@ -3007,7 +3007,7 @@ RecordValPtr RecordVal::CoerceTo(RecordTypePtr t, return nullptr; if ( ! aggr ) - aggr = make_intrusive(std::move(t)); + aggr = make_intrusive(std::move(t)); RecordType* ar_t = aggr->GetType()->AsRecordType(); const RecordType* rv_t = GetType()->AsRecordType(); @@ -3150,7 +3150,7 @@ ValPtr RecordVal::DoClone(CloneState* state) // record. As we cannot guarantee that it will ber zeroed out at the // approproate time (as it seems to be guaranteed for the original record) // we don't touch it. - auto rv = make_intrusive(GetType(), false); + auto rv = make_intrusive(GetType(), false); rv->origin = nullptr; state->NewClone(this, rv); @@ -3174,14 +3174,14 @@ unsigned int RecordVal::MemoryAllocation() const size += v->MemoryAllocation(); } - size += zeek::util::pad_size(vl.capacity() * sizeof(ValPtr)); + size += util::pad_size(vl.capacity() * sizeof(ValPtr)); size += padded_sizeof(vl); return size + padded_sizeof(*this); } ValPtr EnumVal::SizeVal() const { - return zeek::val_mgr->Int(val.int_val); + return val_mgr->Int(val.int_val); } void EnumVal::ValDescribe(ODesc* d) const @@ -3215,7 +3215,7 @@ VectorVal::~VectorVal() ValPtr VectorVal::SizeVal() const { - return zeek::val_mgr->Count(uint32_t(val.vector_val->size())); + return val_mgr->Count(uint32_t(val.vector_val->size())); } bool VectorVal::Assign(unsigned int index, ValPtr element) @@ -3329,7 +3329,7 @@ unsigned int VectorVal::ResizeAtLeast(unsigned int new_num_elements) ValPtr VectorVal::DoClone(CloneState* state) { - auto vv = make_intrusive(GetType()); + auto vv = make_intrusive(GetType()); vv->val.vector_val->reserve(val.vector_val->size()); state->NewClone(this, vv); @@ -3364,7 +3364,7 @@ void VectorVal::ValDescribe(ODesc* d) const ValPtr check_and_promote(ValPtr v, const Type* t, bool is_init, - const zeek::detail::Location* expr_location) + const detail::Location* expr_location) { if ( ! v ) return nullptr; @@ -3431,7 +3431,7 @@ ValPtr check_and_promote(ValPtr v, return nullptr; } else if ( t_tag == TYPE_INT ) - promoted_v = zeek::val_mgr->Int(v->CoerceToInt()); + promoted_v = val_mgr->Int(v->CoerceToInt()); else // enum { reporter->InternalError("bad internal type in check_and_promote()"); @@ -3447,7 +3447,7 @@ ValPtr check_and_promote(ValPtr v, return nullptr; } else if ( t_tag == TYPE_COUNT ) - promoted_v = zeek::val_mgr->Count(v->CoerceToUnsigned()); + promoted_v = val_mgr->Count(v->CoerceToUnsigned()); else // port { reporter->InternalError("bad internal type in check_and_promote()"); @@ -3459,13 +3459,13 @@ ValPtr check_and_promote(ValPtr v, case TYPE_INTERNAL_DOUBLE: switch ( t_tag ) { case TYPE_DOUBLE: - promoted_v = make_intrusive(v->CoerceToDouble()); + promoted_v = make_intrusive(v->CoerceToDouble()); break; case TYPE_INTERVAL: - promoted_v = make_intrusive(v->CoerceToDouble()); + promoted_v = make_intrusive(v->CoerceToDouble()); break; case TYPE_TIME: - promoted_v = make_intrusive(v->CoerceToDouble()); + promoted_v = make_intrusive(v->CoerceToDouble()); break; default: reporter->InternalError("bad internal type in check_and_promote()"); @@ -3579,14 +3579,14 @@ ValPtr cast_value_to_type(Val* v, Type* t) if ( same_type(v->GetType(), t) ) return {NewRef{}, v}; - if ( same_type(v->GetType(), zeek::Broker::detail::DataVal::ScriptDataType()) ) + if ( same_type(v->GetType(), Broker::detail::DataVal::ScriptDataType()) ) { const auto& dv = v->AsRecordVal()->GetField(0); if ( ! dv ) return nullptr; - return static_cast(dv.get())->castTo(t); + return static_cast(dv.get())->castTo(t); } return nullptr; @@ -3605,14 +3605,14 @@ bool can_cast_value_to_type(const Val* v, Type* t) if ( same_type(v->GetType(), t) ) return true; - if ( same_type(v->GetType(), zeek::Broker::detail::DataVal::ScriptDataType()) ) + if ( same_type(v->GetType(), Broker::detail::DataVal::ScriptDataType()) ) { const auto& dv = v->AsRecordVal()->GetField(0); if ( ! dv ) return false; - return static_cast(dv.get())->canCastTo(t); + return static_cast(dv.get())->canCastTo(t); } return false; @@ -3628,7 +3628,7 @@ bool can_cast_value_to_type(const Type* s, Type* t) if ( same_type(s, t) ) return true; - if ( same_type(s, zeek::Broker::detail::DataVal::ScriptDataType()) ) + if ( same_type(s, Broker::detail::DataVal::ScriptDataType()) ) // As Broker is dynamically typed, we don't know if we will be able // to convert the type as intended. We optimistically assume that we // will. @@ -3654,7 +3654,7 @@ ValPtr Val::MakeCount(bro_uint_t u) ValManager::ValManager() { - empty_string = make_intrusive(""); + empty_string = make_intrusive(""); b_false = Val::MakeBool(false); b_true = Val::MakeBool(true); diff --git a/src/Val.h b/src/Val.h index 3f453690cf..177f1a3d00 100644 --- a/src/Val.h +++ b/src/Val.h @@ -61,8 +61,8 @@ extern double zeek_start_network_time; } -using FuncPtr = zeek::IntrusivePtr; -using FilePtr = zeek::IntrusivePtr; +using FuncPtr = IntrusivePtr; +using FilePtr = IntrusivePtr; class Val; class PortVal; @@ -79,15 +79,15 @@ class OpaqueVal; class VectorVal; class TableEntryVal; -using AddrValPtr = zeek::IntrusivePtr; -using EnumValPtr = zeek::IntrusivePtr; -using ListValPtr = zeek::IntrusivePtr; -using PortValPtr = zeek::IntrusivePtr; -using RecordValPtr = zeek::IntrusivePtr; -using StringValPtr = zeek::IntrusivePtr; -using TableValPtr = zeek::IntrusivePtr; -using ValPtr = zeek::IntrusivePtr; -using VectorValPtr = zeek::IntrusivePtr; +using AddrValPtr = IntrusivePtr; +using EnumValPtr = IntrusivePtr; +using ListValPtr = IntrusivePtr; +using PortValPtr = IntrusivePtr; +using RecordValPtr = IntrusivePtr; +using StringValPtr = IntrusivePtr; +using TableValPtr = IntrusivePtr; +using ValPtr = IntrusivePtr; +using VectorValPtr = IntrusivePtr; union BroValUnion { // Used for bool, int, enum. @@ -106,10 +106,10 @@ union BroValUnion { double double_val; String* string_val; - zeek::Func* func_val; + Func* func_val; File* file_val; RE_Matcher* re_val; - zeek::PDict* table_val; + PDict* table_val; std::vector* record_val; std::vector* vector_val; @@ -133,7 +133,7 @@ union BroValUnion { constexpr BroValUnion(String* value) noexcept : string_val(value) {} - constexpr BroValUnion(zeek::Func* value) noexcept + constexpr BroValUnion(Func* value) noexcept : func_val(value) {} constexpr BroValUnion(File* value) noexcept @@ -142,7 +142,7 @@ union BroValUnion { constexpr BroValUnion(RE_Matcher* value) noexcept : re_val(value) {} - constexpr BroValUnion(zeek::PDict* value) noexcept + constexpr BroValUnion(PDict* value) noexcept : table_val(value) {} }; @@ -151,13 +151,13 @@ public: static inline const ValPtr nil; [[deprecated("Remove in v4.1. Use IntervalVal(), TimeVal(), or DoubleVal() constructors.")]] - Val(double d, zeek::TypeTag t) - : val(d), type(zeek::base_type(t)) + Val(double d, TypeTag t) + : val(d), type(base_type(t)) {} [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit Val(zeek::Func* f); - explicit Val(zeek::FuncPtr f); + explicit Val(Func* f); + explicit Val(FuncPtr f); [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] explicit Val(File* f); @@ -166,16 +166,16 @@ public: explicit Val(FilePtr f); // Extra arg to differentiate from protected version. - Val(zeek::TypePtr t, bool type_type) - : type(zeek::make_intrusive(std::move(t))) + Val(TypePtr t, bool type_type) + : type(make_intrusive(std::move(t))) {} [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - Val(zeek::Type* t, bool type_type) : Val({zeek::NewRef{}, t}, type_type) + Val(zeek::Type* t, bool type_type) : Val({NewRef{}, t}, type_type) {} Val() - : val(bro_int_t(0)), type(zeek::base_type(zeek::TYPE_ERROR)) + : val(bro_int_t(0)), type(base_type(TYPE_ERROR)) {} ~Val() override; @@ -215,17 +215,17 @@ public: [[deprecated("Remove in v4.1. Use GetType().")]] const zeek::Type* Type() const { return type.get(); } - const zeek::TypePtr& GetType() const + const TypePtr& GetType() const { return type; } template - zeek::IntrusivePtr GetType() const - { return zeek::cast_intrusive(type); } + IntrusivePtr GetType() const + { return cast_intrusive(type); } #define CONST_ACCESSOR(tag, ctype, accessor, name) \ const ctype name() const \ { \ - CHECK_TAG(type->Tag(), tag, "Val::CONST_ACCESSOR", zeek::type_name) \ + CHECK_TAG(type->Tag(), tag, "Val::CONST_ACCESSOR", type_name) \ return val.accessor; \ } @@ -233,71 +233,71 @@ public: #define CONST_ACCESSOR2(tag, ctype, accessor, name) \ ctype name() const \ { \ - CHECK_TAG(type->Tag(), tag, "Val::CONST_ACCESSOR", zeek::type_name) \ + CHECK_TAG(type->Tag(), tag, "Val::CONST_ACCESSOR", type_name) \ return val.accessor; \ } - CONST_ACCESSOR2(zeek::TYPE_BOOL, bool, int_val, AsBool) - CONST_ACCESSOR2(zeek::TYPE_INT, bro_int_t, int_val, AsInt) - CONST_ACCESSOR2(zeek::TYPE_COUNT, bro_uint_t, uint_val, AsCount) - CONST_ACCESSOR2(zeek::TYPE_DOUBLE, double, double_val, AsDouble) - CONST_ACCESSOR2(zeek::TYPE_TIME, double, double_val, AsTime) - CONST_ACCESSOR2(zeek::TYPE_INTERVAL, double, double_val, AsInterval) - CONST_ACCESSOR2(zeek::TYPE_ENUM, int, int_val, AsEnum) - CONST_ACCESSOR(zeek::TYPE_STRING, String*, string_val, AsString) - CONST_ACCESSOR(zeek::TYPE_FUNC, zeek::Func*, func_val, AsFunc) - CONST_ACCESSOR(zeek::TYPE_TABLE, zeek::PDict*, table_val, AsTable) - CONST_ACCESSOR(zeek::TYPE_RECORD, std::vector*, record_val, AsRecord) - CONST_ACCESSOR(zeek::TYPE_FILE, File*, file_val, AsFile) - CONST_ACCESSOR(zeek::TYPE_PATTERN, RE_Matcher*, re_val, AsPattern) - CONST_ACCESSOR(zeek::TYPE_VECTOR, std::vector*, vector_val, AsVector) + CONST_ACCESSOR2(TYPE_BOOL, bool, int_val, AsBool) + CONST_ACCESSOR2(TYPE_INT, bro_int_t, int_val, AsInt) + CONST_ACCESSOR2(TYPE_COUNT, bro_uint_t, uint_val, AsCount) + CONST_ACCESSOR2(TYPE_DOUBLE, double, double_val, AsDouble) + CONST_ACCESSOR2(TYPE_TIME, double, double_val, AsTime) + CONST_ACCESSOR2(TYPE_INTERVAL, double, double_val, AsInterval) + CONST_ACCESSOR2(TYPE_ENUM, int, int_val, AsEnum) + CONST_ACCESSOR(TYPE_STRING, String*, string_val, AsString) + CONST_ACCESSOR(TYPE_FUNC, Func*, func_val, AsFunc) + CONST_ACCESSOR(TYPE_TABLE, PDict*, table_val, AsTable) + CONST_ACCESSOR(TYPE_RECORD, std::vector*, record_val, AsRecord) + CONST_ACCESSOR(TYPE_FILE, File*, file_val, AsFile) + CONST_ACCESSOR(TYPE_PATTERN, RE_Matcher*, re_val, AsPattern) + CONST_ACCESSOR(TYPE_VECTOR, std::vector*, vector_val, AsVector) const IPPrefix& AsSubNet() const { - CHECK_TAG(type->Tag(), zeek::TYPE_SUBNET, "Val::SubNet", zeek::type_name) + CHECK_TAG(type->Tag(), TYPE_SUBNET, "Val::SubNet", type_name) return *val.subnet_val; } zeek::Type* AsType() const { - CHECK_TAG(type->Tag(), zeek::TYPE_TYPE, "Val::Type", zeek::type_name) + CHECK_TAG(type->Tag(), TYPE_TYPE, "Val::Type", type_name) return type.get(); } const IPAddr& AsAddr() const { - if ( type->Tag() != zeek::TYPE_ADDR ) - BadTag("Val::AsAddr", zeek::type_name(type->Tag())); + if ( type->Tag() != TYPE_ADDR ) + BadTag("Val::AsAddr", type_name(type->Tag())); return *val.addr_val; } #define ACCESSOR(tag, ctype, accessor, name) \ ctype name() \ { \ - CHECK_TAG(type->Tag(), tag, "Val::ACCESSOR", zeek::type_name) \ + CHECK_TAG(type->Tag(), tag, "Val::ACCESSOR", type_name) \ return val.accessor; \ } // Accessors for mutable values are called AsNonConst* and // are protected to avoid external state changes. - // ACCESSOR(zeek::TYPE_STRING, String*, string_val, AsString) - ACCESSOR(zeek::TYPE_FUNC, zeek::Func*, func_val, AsFunc) - ACCESSOR(zeek::TYPE_FILE, File*, file_val, AsFile) - ACCESSOR(zeek::TYPE_PATTERN, RE_Matcher*, re_val, AsPattern) - ACCESSOR(zeek::TYPE_VECTOR, std::vector*, vector_val, AsVector) + // ACCESSOR(TYPE_STRING, String*, string_val, AsString) + ACCESSOR(TYPE_FUNC, Func*, func_val, AsFunc) + ACCESSOR(TYPE_FILE, File*, file_val, AsFile) + ACCESSOR(TYPE_PATTERN, RE_Matcher*, re_val, AsPattern) + ACCESSOR(TYPE_VECTOR, std::vector*, vector_val, AsVector) - zeek::FuncPtr AsFuncPtr() const; + FuncPtr AsFuncPtr() const; const IPPrefix& AsSubNet() { - CHECK_TAG(type->Tag(), zeek::TYPE_SUBNET, "Val::SubNet", zeek::type_name) + CHECK_TAG(type->Tag(), TYPE_SUBNET, "Val::SubNet", type_name) return *val.subnet_val; } const IPAddr& AsAddr() { - if ( type->Tag() != zeek::TYPE_ADDR ) - BadTag("Val::AsAddr", zeek::type_name(type->Tag())); + if ( type->Tag() != TYPE_ADDR ) + BadTag("Val::AsAddr", type_name(type->Tag())); return *val.addr_val; } @@ -344,14 +344,14 @@ public: // To be overridden by mutable derived class to enable change // notification. - virtual zeek::notifier::detail::Modifiable* Modifiable() { return nullptr; } + virtual notifier::detail::Modifiable* Modifiable() { return nullptr; } #ifdef DEBUG // For debugging, we keep a reference to the global ID to which a // value has been bound *last*. - zeek::detail::ID* GetID() const; + detail::ID* GetID() const; - void SetID(zeek::detail::ID* id); + void SetID(detail::ID* id); #endif static bool WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val); @@ -362,7 +362,7 @@ public: protected: - friend class zeek::EnumType; + friend class EnumType; friend class ListVal; friend class RecordVal; friend class VectorVal; @@ -377,21 +377,21 @@ protected: static ValPtr MakeCount(bro_uint_t u); template - Val(V&& v, zeek::TypeTag t) noexcept - : val(std::forward(v)), type(zeek::base_type(t)) + Val(V&& v, TypeTag t) noexcept + : val(std::forward(v)), type(base_type(t)) {} template - Val(V&& v, zeek::TypePtr t) noexcept + Val(V&& v, TypePtr t) noexcept : val(std::forward(v)), type(std::move(t)) {} - explicit Val(zeek::TypePtr t) noexcept + explicit Val(TypePtr t) noexcept : type(std::move(t)) {} - ACCESSOR(zeek::TYPE_TABLE, zeek::PDict*, table_val, AsNonConstTable) - ACCESSOR(zeek::TYPE_RECORD, std::vector*, record_val, AsNonConstRecord) + ACCESSOR(TYPE_TABLE, PDict*, table_val, AsNonConstTable) + ACCESSOR(TYPE_RECORD, std::vector*, record_val, AsNonConstRecord) // For internal use by the Val::Clone() methods. struct CloneState { @@ -407,7 +407,7 @@ protected: virtual ValPtr DoClone(CloneState* state); BroValUnion val; - zeek::TypePtr type; + TypePtr type; #ifdef DEBUG // For debugging, we keep the name of the ID to which a Val is bound. @@ -516,7 +516,7 @@ extern ValManager* val_mgr; class IntervalVal final : public Val { public: IntervalVal(double quantity, double units = Seconds) - : Val(quantity * units, zeek::base_type(zeek::TYPE_INTERVAL)) + : Val(quantity * units, base_type(TYPE_INTERVAL)) {} protected: @@ -526,14 +526,14 @@ protected: class TimeVal final : public Val { public: TimeVal(double t) - : Val(t, zeek::base_type(zeek::TYPE_TIME)) + : Val(t, base_type(TYPE_TIME)) {} }; class DoubleVal final : public Val { public: DoubleVal(double v) - : Val(v, zeek::base_type(zeek::TYPE_DOUBLE)) + : Val(v, base_type(TYPE_DOUBLE)) {} }; @@ -672,11 +672,11 @@ protected: // element in their index. class ListVal final : public Val { public: - explicit ListVal(zeek::TypeTag t); + explicit ListVal(TypeTag t); ~ListVal() override; - zeek::TypeTag BaseTag() const { return tag; } + TypeTag BaseTag() const { return tag; } ValPtr SizeVal() const override; @@ -724,7 +724,7 @@ protected: ValPtr DoClone(CloneState* state) override; std::vector vals; - zeek::TypeTag tag; + TypeTag tag; }; class TableEntryVal { @@ -761,7 +761,7 @@ protected: int expire_access_time; }; -class TableValTimer final : public zeek::detail::Timer { +class TableValTimer final : public detail::Timer { public: TableValTimer(TableVal* val, double t); ~TableValTimer() override; @@ -774,13 +774,13 @@ protected: TableVal* table; }; -class TableVal final : public Val, public zeek::notifier::detail::Modifiable { +class TableVal final : public Val, public notifier::detail::Modifiable { public: - explicit TableVal(zeek::TableTypePtr t, zeek::detail::AttributesPtr attrs = nullptr); + explicit TableVal(TableTypePtr t, detail::AttributesPtr attrs = nullptr); [[deprecated("Remove in v4.1. Construct from IntrusivePtrs instead.")]] - explicit TableVal(zeek::TableType* t, zeek::detail::Attributes* attrs = nullptr) - : TableVal({zeek::NewRef{}, t}, {zeek::NewRef{}, attrs}) + explicit TableVal(TableType* t, detail::Attributes* attrs = nullptr) + : TableVal({NewRef{}, t}, {NewRef{}, attrs}) {} ~TableVal() override; @@ -809,7 +809,7 @@ public: * Broker stores. * @return True if the assignment type-checked. */ - bool Assign(ValPtr index, std::unique_ptr k, + bool Assign(ValPtr index, std::unique_ptr k, ValPtr new_val, bool broker_forward = true); // Returns true if the assignment typechecked, false if not. The @@ -818,10 +818,10 @@ public: [[deprecated("Remove in v4.1. Use IntrusivePtr overload instead.")]] bool Assign(Val* index, Val* new_val); - // Same as other Assign() method, but takes a precomuted zeek::detail::HashKey and + // Same as other Assign() method, but takes a precomuted detail::HashKey and // deletes it when done. [[deprecated("Remove in v4.1. Use IntrusivePtr overload instead.")]] - bool Assign(Val* index, zeek::detail::HashKey* k, Val* new_val); + bool Assign(Val* index, detail::HashKey* k, Val* new_val); ValPtr SizeVal() const override; @@ -923,10 +923,10 @@ public: /** * @return The index corresponding to the given HashKey. */ - ListValPtr RecreateIndex(const zeek::detail::HashKey& k) const; + ListValPtr RecreateIndex(const detail::HashKey& k) const; [[deprecated("Remove in v4.1. Use RecreateIndex().")]] - ListVal* RecoverIndex(const zeek::detail::HashKey* k) const + ListVal* RecoverIndex(const detail::HashKey* k) const { return RecreateIndex(*k).release(); } /** @@ -946,36 +946,36 @@ public: * @param k The hash key to lookup. * @return Same as Remove(const Val&). */ - ValPtr Remove(const zeek::detail::HashKey& k); + ValPtr Remove(const detail::HashKey& k); [[deprecated("Remove in v4.1. Use Remove().")]] Val* Delete(const Val* index) { return Remove(*index).release(); } [[deprecated("Remove in v4.1. Use Remove().")]] - Val* Delete(const zeek::detail::HashKey* k) + Val* Delete(const detail::HashKey* k) { return Remove(*k).release(); } // Returns a ListVal representation of the table (which must be a set). - ListValPtr ToListVal(zeek::TypeTag t = zeek::TYPE_ANY) const; + ListValPtr ToListVal(TypeTag t = TYPE_ANY) const; // Returns a ListVal representation of the table (which must be a set // with non-composite index type). ListValPtr ToPureListVal() const; [[deprecated("Remove in v4.1. Use ToListVal() instead.")]] - ListVal* ConvertToList(zeek::TypeTag t=zeek::TYPE_ANY) const; + ListVal* ConvertToList(TypeTag t=TYPE_ANY) const; [[deprecated("Remove in v4.1. Use ToPureListVal() instead.")]] ListVal* ConvertToPureList() const; // must be single index type - void SetAttrs(zeek::detail::AttributesPtr attrs); + void SetAttrs(detail::AttributesPtr attrs); - const zeek::detail::AttrPtr& GetAttr(zeek::detail::AttrTag t) const; + const detail::AttrPtr& GetAttr(detail::AttrTag t) const; [[deprecated("Remove in v4.1. Use GetAttrs().")]] - zeek::detail::Attributes* Attrs() { return attrs.get(); } + detail::Attributes* Attrs() { return attrs.get(); } - const zeek::detail::AttributesPtr& GetAttrs() const + const detail::AttributesPtr& GetAttrs() const { return attrs; } // Returns the size of the table. @@ -985,7 +985,7 @@ public: // Returns the Prefix table used inside the table (if present). // This allows us to do more direct queries to this specialized // type that the general Table API does not allow. - const zeek::detail::PrefixTable* Subnets() const { return subnets; } + const detail::PrefixTable* Subnets() const { return subnets; } void Describe(ODesc* d) const override; @@ -995,11 +995,11 @@ public: // If the &default attribute is not a function, or the functon has // already been initialized, this does nothing. Otherwise, evaluates // the function in the frame allowing it to capture its closure. - void InitDefaultFunc(zeek::detail::Frame* f); + void InitDefaultFunc(detail::Frame* f); unsigned int MemoryAllocation() const override; - void ClearTimer(zeek::detail::Timer* t) + void ClearTimer(detail::Timer* t) { if ( timer == t ) timer = nullptr; @@ -1010,16 +1010,16 @@ public: * @return The hash of the index value or nullptr if * type-checking failed. */ - std::unique_ptr MakeHashKey(const Val& index) const; + std::unique_ptr MakeHashKey(const Val& index) const; [[deprecated("Remove in v4.1. Use MakeHashKey().")]] - zeek::detail::HashKey* ComputeHash(const Val* index) const; + detail::HashKey* ComputeHash(const Val* index) const; - zeek::notifier::detail::Modifiable* Modifiable() override { return this; } + notifier::detail::Modifiable* Modifiable() override { return this; } // Retrieves and saves all table state (key-value pairs) for - // tables whose index type depends on the given zeek::RecordType. - static void SaveParseTimeTableState(zeek::RecordType* rt); + // tables whose index type depends on the given RecordType. + static void SaveParseTimeTableState(RecordType* rt); // Rebuilds all TableVals whose state was previously saved by // SaveParseTimeTableState(). This is used to re-recreate the tables @@ -1027,7 +1027,7 @@ public: static void RebuildParseTimeTables(); // Clears all state that was used to track TableVals that depending - // on zeek::RecordTypes. + // on RecordTypes. static void DoneParsing(); /** @@ -1047,9 +1047,9 @@ public: void EnableChangeNotifications() { in_change_func = false; } protected: - void Init(zeek::TableTypePtr t); + void Init(TableTypePtr t); - using TableRecordDependencies = std::unordered_map>; + using TableRecordDependencies = std::unordered_map>; using ParseTimeTableState = std::vector>; using ParseTimeTableStates = std::unordered_map; @@ -1057,7 +1057,7 @@ protected: ParseTimeTableState DumpTableState(); void RebuildTable(ParseTimeTableState ptts); - void CheckExpireAttr(zeek::detail::AttrTag at); + void CheckExpireAttr(detail::AttrTag at); bool ExpandCompoundAndInit(ListVal* lv, int k, ValPtr new_val); bool CheckAndAssign(ValPtr index, ValPtr new_val); @@ -1087,16 +1087,16 @@ protected: ValPtr DoClone(CloneState* state) override; - zeek::TableTypePtr table_type; - zeek::detail::CompositeHash* table_hash; - zeek::detail::AttributesPtr attrs; - zeek::detail::ExprPtr expire_time; - zeek::detail::ExprPtr expire_func; + TableTypePtr table_type; + detail::CompositeHash* table_hash; + detail::AttributesPtr attrs; + detail::ExprPtr expire_time; + detail::ExprPtr expire_func; TableValTimer* timer; IterCookie* expire_cookie; - zeek::detail::PrefixTable* subnets; + detail::PrefixTable* subnets; ValPtr def_val; - zeek::detail::ExprPtr change_func; + detail::ExprPtr change_func; std::string broker_store; // prevent recursion of change functions bool in_change_func = false; @@ -1105,11 +1105,11 @@ protected: static ParseTimeTableStates parse_time_table_states; }; -class RecordVal final : public Val, public zeek::notifier::detail::Modifiable { +class RecordVal final : public Val, public notifier::detail::Modifiable { public: [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit RecordVal(zeek::RecordType* t, bool init_fields = true); - explicit RecordVal(zeek::RecordTypePtr t, bool init_fields = true); + explicit RecordVal(RecordType* t, bool init_fields = true); + explicit RecordVal(RecordTypePtr t, bool init_fields = true); ~RecordVal() override; @@ -1131,7 +1131,7 @@ public: */ template void Assign(int field, Ts&&... args) - { Assign(field, zeek::make_intrusive(std::forward(args)...)); } + { Assign(field, make_intrusive(std::forward(args)...)); } [[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]] void Assign(int field, Val* new_val); @@ -1157,8 +1157,8 @@ public: * @return The value at the given field index cast to type @c T. */ template - zeek::IntrusivePtr GetField(int field) const - { return zeek::cast_intrusive(GetField(field)); } + IntrusivePtr GetField(int field) const + { return cast_intrusive(GetField(field)); } /** * Returns the value of a given field index if it's previously been @@ -1189,8 +1189,8 @@ public: * field name exists, a fatal error occurs. */ template - zeek::IntrusivePtr GetField(const char* field) const - { return zeek::cast_intrusive(GetField(field)); } + IntrusivePtr GetField(const char* field) const + { return cast_intrusive(GetField(field)); } /** * Returns the value of a given field name if it's previously been @@ -1211,8 +1211,8 @@ public: * type @c T. If no such field name exists, a fatal error occurs. */ template - zeek::IntrusivePtr GetFieldOrDefault(const char* field) const - { return zeek::cast_intrusive(GetField(field)); } + IntrusivePtr GetFieldOrDefault(const char* field) const + { return cast_intrusive(GetField(field)); } /** * Looks up the value of a field by field name. If the field doesn't @@ -1249,21 +1249,21 @@ public: // // The *allow_orphaning* parameter allows for a record to be demoted // down to a record type that contains less fields. - RecordValPtr CoerceTo(zeek::RecordTypePtr other, + RecordValPtr CoerceTo(RecordTypePtr other, RecordValPtr aggr, bool allow_orphaning = false) const; - RecordValPtr CoerceTo(zeek::RecordTypePtr other, + RecordValPtr CoerceTo(RecordTypePtr other, bool allow_orphaning = false); unsigned int MemoryAllocation() const override; void DescribeReST(ODesc* d) const override; - zeek::notifier::detail::Modifiable* Modifiable() override { return this; } + notifier::detail::Modifiable* Modifiable() override { return this; } // Extend the underlying arrays of record instances created during // parsing to match the number of fields in the record type (they may // mismatch as a result of parse-time record type redefinitions. - static void ResizeParseTimeRecords(zeek::RecordType* rt); + static void ResizeParseTimeRecords(RecordType* rt); static void DoneParsing(); @@ -1272,7 +1272,7 @@ protected: Obj* origin; - using RecordTypeValMap = std::unordered_map>; + using RecordTypeValMap = std::unordered_map>; static RecordTypeValMap parse_time_records; }; @@ -1282,12 +1282,12 @@ public: protected: friend class Val; - friend class zeek::EnumType; + friend class EnumType; template - friend zeek::IntrusivePtr zeek::make_intrusive(Ts&&... args); + friend IntrusivePtr make_intrusive(Ts&&... args); - EnumVal(zeek::EnumTypePtr t, bro_int_t i) : Val(i, std::move(t)) + EnumVal(EnumTypePtr t, bro_int_t i) : Val(i, std::move(t)) {} void ValDescribe(ODesc* d) const override; @@ -1295,11 +1295,11 @@ protected: }; -class VectorVal final : public Val, public zeek::notifier::detail::Modifiable { +class VectorVal final : public Val, public notifier::detail::Modifiable { public: [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit VectorVal(zeek::VectorType* t); - explicit VectorVal(zeek::VectorTypePtr t); + explicit VectorVal(VectorType* t); + explicit VectorVal(VectorTypePtr t); ~VectorVal() override; ValPtr SizeVal() const override; @@ -1317,7 +1317,7 @@ public: // the element was just created and thus has refcount 1. [[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]] bool Assign(unsigned int index, Val* element) - { return Assign(index, {zeek::AdoptRef{}, element}); } + { return Assign(index, {AdoptRef{}, element}); } // Note: the following nullptr method can also go upon removing the above. void Assign(unsigned int index, std::nullptr_t) { Assign(index, ValPtr{}); } @@ -1326,7 +1326,7 @@ public: bool Assign(Val* index, Val* element) { return Assign(index->AsListVal()->Idx(0)->CoerceToUnsigned(), - {zeek::AdoptRef{}, element}); + {AdoptRef{}, element}); } /** @@ -1341,7 +1341,7 @@ public: [[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]] bool AssignRepeat(unsigned int index, unsigned int how_many, Val* element) - { return AssignRepeat(index, how_many, {zeek::NewRef{}, element}); } + { return AssignRepeat(index, how_many, {NewRef{}, element}); } // Add this value to the given value (if appropriate). // Returns true if succcessful. @@ -1375,7 +1375,7 @@ public: // Won't shrink size. unsigned int ResizeAtLeast(unsigned int new_num_elements); - zeek::notifier::detail::Modifiable* Modifiable() override { return this; } + notifier::detail::Modifiable* Modifiable() override { return this; } /** * Inserts an element at the given position in the vector. All elements @@ -1389,7 +1389,7 @@ public: [[deprecated("Remove in v4.1. Insert an IntrusivePtr instead.")]] bool Insert(unsigned int index, Val* element) - { return Insert(index, {zeek::AdoptRef{}, element}); } + { return Insert(index, {AdoptRef{}, element}); } // Removes an element at a specific position. bool Remove(unsigned int index); @@ -1404,8 +1404,8 @@ protected: // If not a match, generates an error message and return nil. If is_init is // true, then the checking is done in the context of an initialization. extern ValPtr check_and_promote( - ValPtr v, const zeek::Type* t, bool is_init, - const zeek::detail::Location* expr_location = nullptr); + ValPtr v, const Type* t, bool is_init, + const detail::Location* expr_location = nullptr); extern bool same_val(const Val* v1, const Val* v2); extern bool same_atomic_val(const Val* v1, const Val* v2); @@ -1416,25 +1416,25 @@ extern void describe_vals(const std::vector& vals, extern void delete_vals(ValPList* vals); // True if the given Val* has a vector type. -inline bool is_vector(Val* v) { return v->GetType()->Tag() == zeek::TYPE_VECTOR; } +inline bool is_vector(Val* v) { return v->GetType()->Tag() == TYPE_VECTOR; } inline bool is_vector(const ValPtr& v) { return is_vector(v.get()); } // Returns v casted to type T if the type supports that. Returns null if not. // // Note: This implements the script-level cast operator. -extern ValPtr cast_value_to_type(Val* v, zeek::Type* t); +extern ValPtr cast_value_to_type(Val* v, Type* t); // Returns true if v can be casted to type T. If so, check_and_cast() will // succeed as well. // // Note: This implements the script-level type comparision operator. -extern bool can_cast_value_to_type(const Val* v, zeek::Type* t); +extern bool can_cast_value_to_type(const Val* v, Type* t); // Returns true if values of type s may support casting to type t. This is // purely static check to weed out cases early on that will never succeed. // However, even this function returns true, casting may still fail for a // specific instance later. -extern bool can_cast_value_to_type(const zeek::Type* s, zeek::Type* t); +extern bool can_cast_value_to_type(const Type* s, Type* t); } // namespace zeek diff --git a/src/Var.cc b/src/Var.cc index 174704e069..c1b3941e37 100644 --- a/src/Var.cc +++ b/src/Var.cc @@ -19,28 +19,28 @@ namespace zeek::detail { -static zeek::ValPtr init_val(zeek::detail::Expr* init, - const zeek::Type* t, - zeek::ValPtr aggr) +static ValPtr init_val(Expr* init, + const Type* t, + ValPtr aggr) { try { return init->InitVal(t, std::move(aggr)); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { return nullptr; } } -static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, +static bool add_prototype(const IDPtr& id, Type* t, std::vector* attrs, - const zeek::detail::ExprPtr& init) + const ExprPtr& init) { - if ( ! zeek::IsFunc(id->GetType()->Tag()) ) + if ( ! IsFunc(id->GetType()->Tag()) ) return false; - if ( ! zeek::IsFunc(t->Tag()) ) + if ( ! IsFunc(t->Tag()) ) { t->Error("type incompatible with previous definition", id.get()); return false; @@ -55,7 +55,7 @@ static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, return false; } - if ( canon_ft->Flavor() == zeek::FUNC_FLAVOR_FUNCTION ) + if ( canon_ft->Flavor() == FUNC_FLAVOR_FUNCTION ) { alt_ft->Error("redeclaration of function", canon_ft); return false; @@ -84,7 +84,7 @@ static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, if ( alt_args->FieldDecl(i)->attrs ) { - alt_ft->Error(zeek::util::fmt("alternate function prototype arguments may not have attributes: arg '%s'", field), canon_ft); + alt_ft->Error(util::fmt("alternate function prototype arguments may not have attributes: arg '%s'", field), canon_ft); return false; } @@ -92,7 +92,7 @@ static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, if ( o < 0 ) { - alt_ft->Error(zeek::util::fmt("alternate function prototype arg '%s' not found in canonical prototype", field), canon_ft); + alt_ft->Error(util::fmt("alternate function prototype arg '%s' not found in canonical prototype", field), canon_ft); return false; } @@ -104,14 +104,14 @@ static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, if ( attrs ) for ( const auto& a : *attrs ) - if ( a->Tag() == zeek::detail::ATTR_DEPRECATED ) + if ( a->Tag() == ATTR_DEPRECATED ) { deprecated = true; depr_msg = a->DeprecationMessage(); break; } - zeek::FuncType::Prototype p; + FuncType::Prototype p; p.deprecated = deprecated; p.deprecation_msg = std::move(depr_msg); p.args = alt_args; @@ -121,25 +121,25 @@ static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t, return true; } -static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, - zeek::detail::InitClass c, - zeek::detail::ExprPtr init, +static void make_var(const IDPtr& id, TypePtr t, + InitClass c, + ExprPtr init, std::unique_ptr> attr, DeclType dt, bool do_init) { if ( id->GetType() ) { - if ( id->IsRedefinable() || (! init && attr && ! zeek::IsFunc(id->GetType()->Tag())) ) + if ( id->IsRedefinable() || (! init && attr && ! IsFunc(id->GetType()->Tag())) ) { - zeek::Obj* redef_obj = init ? (zeek::Obj*) init.get() : (zeek::Obj*) t.get(); + Obj* redef_obj = init ? (Obj*) init.get() : (Obj*) t.get(); if ( dt != VAR_REDEF ) id->Warn("redefinition requires \"redef\"", redef_obj, true); } else if ( dt != VAR_REDEF || init || ! attr ) { - if ( zeek::IsFunc(id->GetType()->Tag()) ) + if ( IsFunc(id->GetType()->Tag()) ) add_prototype(id, t.get(), attr.get(), init); else id->Error("already defined", init.get()); @@ -160,10 +160,10 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, t = id->GetType(); } - if ( id->GetType() && id->GetType()->Tag() != zeek::TYPE_ERROR ) + if ( id->GetType() && id->GetType()->Tag() != TYPE_ERROR ) { if ( dt != VAR_REDEF && - (! init || ! do_init || (! t && ! (t = zeek::init_type(init.get())))) ) + (! init || ! do_init || (! t && ! (t = init_type(init.get())))) ) { id->Error("already defined", init.get()); return; @@ -179,7 +179,7 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, if ( t && t->IsSet() ) { // Check for set with explicit elements. - zeek::SetType* st = t->AsTableType()->AsSetType(); + SetType* st = t->AsTableType()->AsSetType(); const auto& elements = st->Elements(); if ( elements ) @@ -202,10 +202,10 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, return; } - t = zeek::init_type(init.get()); + t = init_type(init.get()); if ( ! t ) { - id->SetType(zeek::error_type()); + id->SetType(error_type()); return; } } @@ -213,22 +213,22 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, id->SetType(t); if ( attr ) - id->AddAttrs(zeek::make_intrusive(std::move(*attr), t, false, id->IsGlobal())); + id->AddAttrs(make_intrusive(std::move(*attr), t, false, id->IsGlobal())); if ( init ) { switch ( init->Tag() ) { - case zeek::detail::EXPR_TABLE_CONSTRUCTOR: + case EXPR_TABLE_CONSTRUCTOR: { - auto* ctor = static_cast(init.get()); + auto* ctor = static_cast(init.get()); if ( ctor->GetAttrs() ) id->AddAttrs(ctor->GetAttrs()); } break; - case zeek::detail::EXPR_SET_CONSTRUCTOR: + case EXPR_SET_CONSTRUCTOR: { - auto* ctor = static_cast(init.get()); + auto* ctor = static_cast(init.get()); if ( ctor->GetAttrs() ) id->AddAttrs(ctor->GetAttrs()); } @@ -241,40 +241,40 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, if ( do_init ) { - if ( c == zeek::detail::INIT_NONE && dt == VAR_REDEF && t->IsTable() && - init && init->Tag() == zeek::detail::EXPR_ASSIGN ) + if ( c == INIT_NONE && dt == VAR_REDEF && t->IsTable() && + init && init->Tag() == EXPR_ASSIGN ) // e.g. 'redef foo["x"] = 1' is missing an init class, but the // intention clearly isn't to overwrite entire existing table val. - c = zeek::detail::INIT_EXTRA; + c = INIT_EXTRA; - if ( init && ((c == zeek::detail::INIT_EXTRA && id->GetAttr(zeek::detail::ATTR_ADD_FUNC)) || - (c == zeek::detail::INIT_REMOVE && id->GetAttr(zeek::detail::ATTR_DEL_FUNC)) )) + if ( init && ((c == INIT_EXTRA && id->GetAttr(ATTR_ADD_FUNC)) || + (c == INIT_REMOVE && id->GetAttr(ATTR_DEL_FUNC)) )) // Just apply the function. id->SetVal(init, c); else if ( dt != VAR_REDEF || init || ! attr ) { - zeek::ValPtr aggr; + ValPtr aggr; - if ( t->Tag() == zeek::TYPE_RECORD ) + if ( t->Tag() == TYPE_RECORD ) { - aggr = zeek::make_intrusive(zeek::cast_intrusive(t)); + aggr = make_intrusive(cast_intrusive(t)); if ( init && t ) // Have an initialization and type is not deduced. - init = zeek::make_intrusive( + init = make_intrusive( std::move(init), - zeek::IntrusivePtr{zeek::NewRef{}, t->AsRecordType()}); + IntrusivePtr{NewRef{}, t->AsRecordType()}); } - else if ( t->Tag() == zeek::TYPE_TABLE ) - aggr = zeek::make_intrusive(zeek::cast_intrusive(t), + else if ( t->Tag() == TYPE_TABLE ) + aggr = make_intrusive(cast_intrusive(t), id->GetAttrs()); - else if ( t->Tag() == zeek::TYPE_VECTOR ) - aggr = zeek::make_intrusive(zeek::cast_intrusive(t)); + else if ( t->Tag() == TYPE_VECTOR ) + aggr = make_intrusive(cast_intrusive(t)); - zeek::ValPtr v; + ValPtr v; if ( init ) { @@ -309,32 +309,32 @@ static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t, id->UpdateValAttrs(); - if ( t && t->Tag() == zeek::TYPE_FUNC && - (t->AsFuncType()->Flavor() == zeek::FUNC_FLAVOR_EVENT || - t->AsFuncType()->Flavor() == zeek::FUNC_FLAVOR_HOOK) ) + if ( t && t->Tag() == TYPE_FUNC && + (t->AsFuncType()->Flavor() == FUNC_FLAVOR_EVENT || + t->AsFuncType()->Flavor() == FUNC_FLAVOR_HOOK) ) { // For events, add a function value (without any body) here so that // we can later access the ID even if no implementations have been // defined. - std::vector inits; - auto f = zeek::make_intrusive(id, nullptr, inits, 0, 0); - id->SetVal(zeek::make_intrusive(std::move(f))); + std::vector inits; + auto f = make_intrusive(id, nullptr, inits, 0, 0); + id->SetVal(make_intrusive(std::move(f))); } } void add_global( - const zeek::detail::IDPtr& id, - zeek::TypePtr t, - zeek::detail::InitClass c, zeek::detail::ExprPtr init, + const IDPtr& id, + TypePtr t, + InitClass c, ExprPtr init, std::unique_ptr> attr, DeclType dt) { make_var(id, std::move(t), c, std::move(init), std::move(attr), dt, true); } -zeek::detail::StmtPtr add_local( - zeek::detail::IDPtr id, zeek::TypePtr t, - zeek::detail::InitClass c, zeek::detail::ExprPtr init, +StmtPtr add_local( + IDPtr id, TypePtr t, + InitClass c, ExprPtr init, std::unique_ptr> attr, DeclType dt) { @@ -342,48 +342,48 @@ zeek::detail::StmtPtr add_local( if ( init ) { - if ( c != zeek::detail::INIT_FULL ) + if ( c != INIT_FULL ) id->Error("can't use += / -= for initializations of local variables"); // copy Location to the stack, because AssignExpr may free "init" - const zeek::detail::Location location = init->GetLocationInfo() ? - *init->GetLocationInfo() : zeek::detail::no_location; + const Location location = init->GetLocationInfo() ? + *init->GetLocationInfo() : no_location; - auto name_expr = zeek::make_intrusive(id, dt == VAR_CONST); - auto assign_expr = zeek::make_intrusive(std::move(name_expr), - std::move(init), 0, - nullptr, id->GetAttrs()); - auto stmt = zeek::make_intrusive(std::move(assign_expr)); + auto name_expr = make_intrusive(id, dt == VAR_CONST); + auto assign_expr = make_intrusive(std::move(name_expr), + std::move(init), 0, + nullptr, id->GetAttrs()); + auto stmt = make_intrusive(std::move(assign_expr)); stmt->SetLocationInfo(&location); return stmt; } else { - zeek::detail::current_scope()->AddInit(std::move(id)); - return zeek::make_intrusive(); + current_scope()->AddInit(std::move(id)); + return make_intrusive(); } } -extern zeek::detail::ExprPtr add_and_assign_local( - zeek::detail::IDPtr id, - zeek::detail::ExprPtr init, - zeek::ValPtr val) +extern ExprPtr add_and_assign_local( + IDPtr id, + ExprPtr init, + ValPtr val) { - make_var(id, nullptr, zeek::detail::INIT_FULL, init, nullptr, VAR_REGULAR, false); - auto name_expr = zeek::make_intrusive(std::move(id)); - return zeek::make_intrusive( + make_var(id, nullptr, INIT_FULL, init, nullptr, VAR_REGULAR, false); + auto name_expr = make_intrusive(std::move(id)); + return make_intrusive( std::move(name_expr), std::move(init), false, std::move(val)); } -void add_type(zeek::detail::ID* id, zeek::TypePtr t, +void add_type(ID* id, TypePtr t, std::unique_ptr> attr) { std::string new_type_name = id->Name(); std::string old_type_name = t->GetName(); - zeek::TypePtr tnew; + TypePtr tnew; - if ( (t->Tag() == zeek::TYPE_RECORD || t->Tag() == zeek::TYPE_ENUM) && + if ( (t->Tag() == TYPE_RECORD || t->Tag() == TYPE_ENUM) && old_type_name.empty() ) // An extensible type (record/enum) being declared for first time. tnew = std::move(t); @@ -391,10 +391,10 @@ void add_type(zeek::detail::ID* id, zeek::TypePtr t, // Clone the type to preserve type name aliasing. tnew = t->ShallowClone(); - zeek::Type::AddAlias(new_type_name, tnew.get()); + Type::AddAlias(new_type_name, tnew.get()); if ( new_type_name != old_type_name && ! old_type_name.empty() ) - zeek::Type::AddAlias(old_type_name, tnew.get()); + Type::AddAlias(old_type_name, tnew.get()); tnew->SetName(id->Name()); @@ -402,17 +402,17 @@ void add_type(zeek::detail::ID* id, zeek::TypePtr t, id->MakeType(); if ( attr ) - id->SetAttrs(zeek::make_intrusive(std::move(*attr), tnew, false, false)); + id->SetAttrs(make_intrusive(std::move(*attr), tnew, false, false)); } -static void transfer_arg_defaults(zeek::RecordType* args, zeek::RecordType* recv) +static void transfer_arg_defaults(RecordType* args, RecordType* recv) { for ( int i = 0; i < args->NumFields(); ++i ) { - zeek::TypeDecl* args_i = args->FieldDecl(i); - zeek::TypeDecl* recv_i = recv->FieldDecl(i); + TypeDecl* args_i = args->FieldDecl(i); + TypeDecl* recv_i = recv->FieldDecl(i); - const auto& def = args_i->attrs ? args_i->attrs->Find(zeek::detail::ATTR_DEFAULT) : nullptr; + const auto& def = args_i->attrs ? args_i->attrs->Find(ATTR_DEFAULT) : nullptr; if ( ! def ) continue; @@ -420,18 +420,18 @@ static void transfer_arg_defaults(zeek::RecordType* args, zeek::RecordType* recv if ( ! recv_i->attrs ) { std::vector a{def}; - recv_i->attrs = zeek::make_intrusive(std::move(a), - recv_i->type, - true, false); + recv_i->attrs = make_intrusive(std::move(a), + recv_i->type, + true, false); } - else if ( ! recv_i->attrs->Find(zeek::detail::ATTR_DEFAULT) ) + else if ( ! recv_i->attrs->Find(ATTR_DEFAULT) ) recv_i->attrs->AddAttr(def); } } -static zeek::detail::Attr* find_attr(const std::vector* al, - zeek::detail::AttrTag tag) +static Attr* find_attr(const std::vector* al, + AttrTag tag) { if ( ! al ) return nullptr; @@ -443,7 +443,7 @@ static zeek::detail::Attr* find_attr(const std::vector* al, return nullptr; } -static std::optional func_type_check(const zeek::FuncType* decl, const zeek::FuncType* impl) +static std::optional func_type_check(const FuncType* decl, const FuncType* impl) { if ( decl->Flavor() != impl->Flavor() ) { @@ -451,7 +451,7 @@ static std::optional func_type_check(const zeek::Func return {}; } - if ( impl->Flavor() == zeek::FUNC_FLAVOR_FUNCTION ) + if ( impl->Flavor() == FUNC_FLAVOR_FUNCTION ) { if ( same_type(decl, impl) ) return decl->Prototypes()[0]; @@ -464,24 +464,24 @@ static std::optional func_type_check(const zeek::Func if ( rval ) for ( auto i = 0; i < rval->args->NumFields(); ++i ) - if ( auto ad = rval->args->FieldDecl(i)->GetAttr(zeek::detail::ATTR_DEPRECATED) ) + if ( auto ad = rval->args->FieldDecl(i)->GetAttr(ATTR_DEPRECATED) ) { auto msg = ad->DeprecationMessage(); if ( msg.empty() ) - impl->Warn(zeek::util::fmt("use of deprecated parameter '%s'", - rval->args->FieldName(i)), + impl->Warn(util::fmt("use of deprecated parameter '%s'", + rval->args->FieldName(i)), decl, true); else - impl->Warn(zeek::util::fmt("use of deprecated parameter '%s': %s", - rval->args->FieldName(i), msg.data()), + impl->Warn(util::fmt("use of deprecated parameter '%s': %s", + rval->args->FieldName(i), msg.data()), decl, true); } return rval; } -static bool canonical_arg_types_match(const zeek::FuncType* decl, const zeek::FuncType* impl) +static bool canonical_arg_types_match(const FuncType* decl, const FuncType* impl) { const auto& canon_args = decl->Params(); const auto& impl_args = impl->Params(); @@ -496,22 +496,22 @@ static bool canonical_arg_types_match(const zeek::FuncType* decl, const zeek::Fu return true; } -void begin_func(zeek::detail::IDPtr id, const char* module_name, - zeek::FunctionFlavor flavor, bool is_redef, - zeek::FuncTypePtr t, +void begin_func(IDPtr id, const char* module_name, + FunctionFlavor flavor, bool is_redef, + FuncTypePtr t, std::unique_ptr> attrs) { - if ( flavor == zeek::FUNC_FLAVOR_EVENT ) + if ( flavor == FUNC_FLAVOR_EVENT ) { const auto& yt = t->Yield(); - if ( yt && yt->Tag() != zeek::TYPE_VOID ) + if ( yt && yt->Tag() != TYPE_VOID ) id->Error("event cannot yield a value", t.get()); t->ClearYieldType(flavor); } - std::optional prototype; + std::optional prototype; if ( id->GetType() ) { @@ -520,7 +520,7 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, if ( prototype ) { - if ( decl->Flavor() == zeek::FUNC_FLAVOR_FUNCTION ) + if ( decl->Flavor() == FUNC_FLAVOR_FUNCTION ) { // If a previous declaration of the function had &default // params, automatically transfer any that are missing @@ -539,13 +539,13 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, { auto f = args->FieldDecl(i); - if ( f->attrs && f->attrs->Find(zeek::detail::ATTR_DEFAULT) ) + if ( f->attrs && f->attrs->Find(ATTR_DEFAULT) ) { - zeek::reporter->PushLocation(args->GetLocationInfo()); - zeek::reporter->Warning( + reporter->PushLocation(args->GetLocationInfo()); + reporter->Warning( "&default on parameter '%s' has no effect (not a %s declaration)", args->FieldName(i), t->FlavorString().data()); - zeek::reporter->PopLocation(); + reporter->PopLocation(); } } } @@ -553,11 +553,11 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, if ( prototype->deprecated ) { if ( prototype->deprecation_msg.empty() ) - t->Warn(zeek::util::fmt("use of deprecated '%s' prototype", id->Name()), + t->Warn(util::fmt("use of deprecated '%s' prototype", id->Name()), prototype->args.get(), true); else - t->Warn(zeek::util::fmt("use of deprecated '%s' prototype: %s", - id->Name(), prototype->deprecation_msg.data()), + t->Warn(util::fmt("use of deprecated '%s' prototype: %s", + id->Name(), prototype->deprecation_msg.data()), prototype->args.get(), true); } } @@ -577,27 +577,27 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, if ( id->HasVal() ) { - zeek::FunctionFlavor id_flavor = id->GetVal()->AsFunc()->Flavor(); + FunctionFlavor id_flavor = id->GetVal()->AsFunc()->Flavor(); if ( id_flavor != flavor ) id->Error("inconsistent function flavor", t.get()); switch ( id_flavor ) { - case zeek::FUNC_FLAVOR_EVENT: - case zeek::FUNC_FLAVOR_HOOK: + case FUNC_FLAVOR_EVENT: + case FUNC_FLAVOR_HOOK: if ( is_redef ) // Clear out value so it will be replaced. id->SetVal(nullptr); break; - case zeek::FUNC_FLAVOR_FUNCTION: + case FUNC_FLAVOR_FUNCTION: if ( ! id->IsRedefinable() ) id->Error("already defined"); break; default: - zeek::reporter->InternalError("invalid function flavor"); + reporter->InternalError("invalid function flavor"); break; } } @@ -607,11 +607,11 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, const auto& args = t->Params(); const auto& canon_args = id->GetType()->AsFuncType()->Params(); - zeek::detail::push_scope(std::move(id), std::move(attrs)); + push_scope(std::move(id), std::move(attrs)); for ( int i = 0; i < canon_args->NumFields(); ++i ) { - zeek::TypeDecl* arg_i; + TypeDecl* arg_i; bool hide = false; if ( prototype ) @@ -638,7 +638,7 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, break; } - auto arg_id = zeek::detail::lookup_ID(arg_i->id, module_name); + auto arg_id = lookup_ID(arg_i->id, module_name); if ( arg_id && ! arg_id->IsGlobal() ) arg_id->Error("argument name used twice"); @@ -648,69 +648,69 @@ void begin_func(zeek::detail::IDPtr id, const char* module_name, if ( hide ) // Note the illegal '-' in hidden name implies we haven't // clobbered any local variable names. - local_name = zeek::util::fmt("%s-hidden", local_name); + local_name = util::fmt("%s-hidden", local_name); - arg_id = zeek::detail::install_ID(local_name, module_name, false, false); + arg_id = install_ID(local_name, module_name, false, false); arg_id->SetType(arg_i->type); } - if ( zeek::detail::Attr* depr_attr = find_attr(zeek::detail::current_scope()->Attrs().get(), - zeek::detail::ATTR_DEPRECATED) ) - zeek::detail::current_scope()->GetID()->MakeDeprecated(depr_attr->GetExpr()); + if ( Attr* depr_attr = find_attr(current_scope()->Attrs().get(), + ATTR_DEPRECATED) ) + current_scope()->GetID()->MakeDeprecated(depr_attr->GetExpr()); } -class OuterIDBindingFinder : public zeek::detail::TraversalCallback { +class OuterIDBindingFinder : public TraversalCallback { public: - OuterIDBindingFinder(zeek::detail::Scope* s) + OuterIDBindingFinder(Scope* s) { scopes.emplace_back(s); } - zeek::detail::TraversalCode PreExpr(const zeek::detail::Expr*) override; - zeek::detail::TraversalCode PostExpr(const zeek::detail::Expr*) override; + TraversalCode PreExpr(const Expr*) override; + TraversalCode PostExpr(const Expr*) override; - std::vector scopes; - std::vector outer_id_references; + std::vector scopes; + std::vector outer_id_references; }; -zeek::detail::TraversalCode OuterIDBindingFinder::PreExpr(const zeek::detail::Expr* expr) +TraversalCode OuterIDBindingFinder::PreExpr(const Expr* expr) { - if ( expr->Tag() == zeek::detail::EXPR_LAMBDA ) + if ( expr->Tag() == EXPR_LAMBDA ) { - auto le = static_cast(expr); + auto le = static_cast(expr); scopes.emplace_back(le->GetScope()); - return zeek::detail::TC_CONTINUE; + return TC_CONTINUE; } - if ( expr->Tag() != zeek::detail::EXPR_NAME ) - return zeek::detail::TC_CONTINUE; + if ( expr->Tag() != EXPR_NAME ) + return TC_CONTINUE; - auto* e = static_cast(expr); + auto* e = static_cast(expr); if ( e->Id()->IsGlobal() ) - return zeek::detail::TC_CONTINUE; + return TC_CONTINUE; for ( const auto& scope : scopes ) if ( scope->Find(e->Id()->Name()) ) // Shadowing is not allowed, so if it's found at inner scope, it's // not something we have to worry about also being at outer scope. - return zeek::detail::TC_CONTINUE; + return TC_CONTINUE; outer_id_references.push_back(e); - return zeek::detail::TC_CONTINUE; + return TC_CONTINUE; } -zeek::detail::TraversalCode OuterIDBindingFinder::PostExpr(const zeek::detail::Expr* expr) +TraversalCode OuterIDBindingFinder::PostExpr(const Expr* expr) { - if ( expr->Tag() == zeek::detail::EXPR_LAMBDA ) + if ( expr->Tag() == EXPR_LAMBDA ) scopes.pop_back(); - return zeek::detail::TC_CONTINUE; + return TC_CONTINUE; } -void end_func(zeek::detail::StmtPtr body) +void end_func(StmtPtr body) { - auto ingredients = std::make_unique(zeek::detail::pop_scope(), + auto ingredients = std::make_unique(pop_scope(), std::move(body)); if ( ingredients->id->HasVal() ) @@ -721,14 +721,14 @@ void end_func(zeek::detail::StmtPtr body) ingredients->priority); else { - auto f = zeek::make_intrusive( + auto f = make_intrusive( ingredients->id, ingredients->body, ingredients->inits, ingredients->frame_size, ingredients->priority); - ingredients->id->SetVal(zeek::make_intrusive(std::move(f))); + ingredients->id->SetVal(make_intrusive(std::move(f))); ingredients->id->SetConst(); } @@ -739,12 +739,12 @@ void end_func(zeek::detail::StmtPtr body) ingredients.release(); } -zeek::Val* internal_val(const char* name) +Val* internal_val(const char* name) { - return zeek::id::find_val(name).get(); + return id::find_val(name).get(); } -IDPList gather_outer_ids(zeek::detail::Scope* scope, zeek::detail::Stmt* body) +IDPList gather_outer_ids(Scope* scope, Stmt* body) { OuterIDBindingFinder cb(scope); body->Traverse(&cb); @@ -764,20 +764,20 @@ IDPList gather_outer_ids(zeek::detail::Scope* scope, zeek::detail::Stmt* body) return idl; } -zeek::Val* internal_const_val(const char* name) +Val* internal_const_val(const char* name) { - return zeek::id::find_const(name).get(); + return id::find_const(name).get(); } -zeek::Val* opt_internal_val(const char* name) +Val* opt_internal_val(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); return id ? id->GetVal().get() : nullptr; } double opt_internal_double(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return 0.0; const auto& v = id->GetVal(); return v ? v->InternalDouble() : 0.0; @@ -785,7 +785,7 @@ double opt_internal_double(const char* name) bro_int_t opt_internal_int(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return 0; const auto& v = id->GetVal(); return v ? v->InternalInt() : 0; @@ -793,63 +793,63 @@ bro_int_t opt_internal_int(const char* name) bro_uint_t opt_internal_unsigned(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return 0; const auto& v = id->GetVal(); return v ? v->InternalUnsigned() : 0; } -zeek::StringVal* opt_internal_string(const char* name) +StringVal* opt_internal_string(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return nullptr; const auto& v = id->GetVal(); return v ? v->AsStringVal() : nullptr; } -zeek::TableVal* opt_internal_table(const char* name) +TableVal* opt_internal_table(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return nullptr; const auto& v = id->GetVal(); return v ? v->AsTableVal() : nullptr; } -zeek::ListVal* internal_list_val(const char* name) +ListVal* internal_list_val(const char* name) { - const auto& id = zeek::detail::lookup_ID(name, GLOBAL_MODULE_NAME); + const auto& id = lookup_ID(name, GLOBAL_MODULE_NAME); if ( ! id ) return nullptr; - zeek::Val* v = id->GetVal().get(); + Val* v = id->GetVal().get(); if ( v ) { - if ( v->GetType()->Tag() == zeek::TYPE_LIST ) - return (zeek::ListVal*) v; + if ( v->GetType()->Tag() == TYPE_LIST ) + return (ListVal*) v; else if ( v->GetType()->IsSet() ) { - zeek::TableVal* tv = v->AsTableVal(); + TableVal* tv = v->AsTableVal(); auto lv = tv->ToPureListVal(); return lv.release(); } else - zeek::reporter->InternalError("internal variable %s is not a list", name); + reporter->InternalError("internal variable %s is not a list", name); } return nullptr; } -zeek::Type* internal_type(const char* name) +Type* internal_type(const char* name) { - return zeek::id::find_type(name).get(); + return id::find_type(name).get(); } -zeek::Func* internal_func(const char* name) +Func* internal_func(const char* name) { - const auto& v = zeek::id::find_val(name); + const auto& v = id::find_val(name); if ( v ) return v->AsFunc(); @@ -857,9 +857,9 @@ zeek::Func* internal_func(const char* name) return nullptr; } -zeek::EventHandlerPtr internal_handler(const char* name) +EventHandlerPtr internal_handler(const char* name) { - return zeek::event_registry->Register(name); + return event_registry->Register(name); } } // namespace zeek::detail diff --git a/src/Var.h b/src/Var.h index 22e539fa25..81f3760d64 100644 --- a/src/Var.h +++ b/src/Var.h @@ -17,42 +17,42 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(Scope, zeek::detail); namespace zeek::detail { -using StmtPtr = zeek::IntrusivePtr; +using StmtPtr = IntrusivePtr; enum DeclType { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, }; -extern void add_global(const zeek::detail::IDPtr& id, - zeek::TypePtr t, - zeek::detail::InitClass c, - zeek::detail::ExprPtr init, - std::unique_ptr> attr, +extern void add_global(const IDPtr& id, + TypePtr t, + InitClass c, + ExprPtr init, + std::unique_ptr> attr, DeclType dt); -extern zeek::detail::StmtPtr add_local( - zeek::detail::IDPtr id, - zeek::TypePtr t, - zeek::detail::InitClass c, - zeek::detail::ExprPtr init, - std::unique_ptr> attr, +extern StmtPtr add_local( + IDPtr id, + TypePtr t, + InitClass c, + ExprPtr init, + std::unique_ptr> attr, DeclType dt); -extern zeek::detail::ExprPtr add_and_assign_local( - zeek::detail::IDPtr id, - zeek::detail::ExprPtr init, - zeek::ValPtr val = nullptr); +extern ExprPtr add_and_assign_local( + IDPtr id, + ExprPtr init, + ValPtr val = nullptr); -extern void add_type(zeek::detail::ID* id, zeek::TypePtr t, - std::unique_ptr> attr); +extern void add_type(ID* id, TypePtr t, + std::unique_ptr> attr); -extern void begin_func(zeek::detail::IDPtr id, const char* module_name, - zeek::FunctionFlavor flavor, bool is_redef, - zeek::FuncTypePtr t, - std::unique_ptr> attrs = nullptr); +extern void begin_func(IDPtr id, const char* module_name, + FunctionFlavor flavor, bool is_redef, + FuncTypePtr t, + std::unique_ptr> attrs = nullptr); -extern void end_func(zeek::detail::StmtPtr body); +extern void end_func(StmtPtr body); // Gather all IDs referenced inside a body that aren't part of a given scope. -extern IDPList gather_outer_ids(zeek::detail::Scope* scope, zeek::detail::Stmt* body); +extern IDPList gather_outer_ids(Scope* scope, Stmt* body); } // namespace zeek::detail diff --git a/src/WeirdState.cc b/src/WeirdState.cc index 83f9bf6719..f94665a06d 100644 --- a/src/WeirdState.cc +++ b/src/WeirdState.cc @@ -14,10 +14,10 @@ bool PermitWeird(WeirdStateMap& wsm, const char* name, uint64_t threshold, return true; if ( state.count == threshold + 1) - state.sampling_start_time = zeek::run_state::network_time; + state.sampling_start_time = run_state::network_time; else { - if ( zeek::run_state::network_time > state.sampling_start_time + duration ) + if ( run_state::network_time > state.sampling_start_time + duration ) { state.sampling_start_time = 0; state.count = 1; diff --git a/src/ZeekArgs.cc b/src/ZeekArgs.cc index 0a80508de6..c2bf61dad6 100644 --- a/src/ZeekArgs.cc +++ b/src/ZeekArgs.cc @@ -4,21 +4,23 @@ #include "ID.h" #include "Desc.h" -zeek::Args zeek::val_list_to_args(const ValPList& vl) +namespace zeek { + +Args val_list_to_args(const ValPList& vl) { - zeek::Args rval; + Args rval; rval.reserve(vl.length()); for ( auto& v : vl ) - rval.emplace_back(zeek::AdoptRef{}, v); + rval.emplace_back(AdoptRef{}, v); return rval; } -zeek::VectorValPtr zeek::MakeCallArgumentVector(const Args& vals, - const RecordTypePtr& types) +VectorValPtr MakeCallArgumentVector(const Args& vals, + const RecordTypePtr& types) { - static auto call_argument_vector = zeek::id::find_type("call_argument_vector"); + static auto call_argument_vector = id::find_type("call_argument_vector"); auto rval = make_intrusive(call_argument_vector); @@ -28,7 +30,7 @@ zeek::VectorValPtr zeek::MakeCallArgumentVector(const Args& vals, const auto& ftype = types->GetFieldType(i); auto fdefault = types->FieldDefault(i); - static auto call_argument = zeek::id::find_type("call_argument"); + static auto call_argument = id::find_type("call_argument"); auto rec = make_intrusive(call_argument); rec->Assign(0, make_intrusive(fname)); @@ -48,3 +50,5 @@ zeek::VectorValPtr zeek::MakeCallArgumentVector(const Args& vals, return rval; } + +} // namespace zeek diff --git a/src/ZeekString.cc b/src/ZeekString.cc index 27d03090f2..350d712a01 100644 --- a/src/ZeekString.cc +++ b/src/ZeekString.cc @@ -279,7 +279,7 @@ void String::ToUpper() unsigned int String::MemoryAllocation() const { - return padded_sizeof(*this) + zeek::util::pad_size(n + final_NUL); + return padded_sizeof(*this) + util::pad_size(n + final_NUL); } String* String::GetSubstring(int start, int len) const @@ -296,7 +296,7 @@ String* String::GetSubstring(int start, int len) const int String::FindSubstring(const String* s) const { - return zeek::util::strstr_n(n, b, s->Len(), s->Bytes()); + return util::strstr_n(n, b, s->Len(), s->Bytes()); } String::Vec* String::Split(const String::IdxVec& indices) const @@ -340,22 +340,22 @@ String::Vec* String::Split(const String::IdxVec& indices) const return result; } -zeek::VectorVal* String:: VecToPolicy(Vec* vec) +VectorVal* String:: VecToPolicy(Vec* vec) { - auto result = zeek::make_intrusive(zeek::id::string_vec); + auto result = make_intrusive(id::string_vec); for ( unsigned int i = 0; i < vec->size(); ++i ) { String* string = (*vec)[i]; - auto val = zeek::make_intrusive(string->Len(), - (const char*) string->Bytes()); + auto val = make_intrusive(string->Len(), + (const char*) string->Bytes()); result->Assign(i+1, std::move(val)); } return result.release(); } -String::Vec* String::VecFromPolicy(zeek::VectorVal* vec) +String::Vec* String::VecFromPolicy(VectorVal* vec) { Vec* result = new Vec(); diff --git a/src/ZeekString.h b/src/ZeekString.h index 0b0ab3db60..b6344ff10f 100644 --- a/src/ZeekString.h +++ b/src/ZeekString.h @@ -138,8 +138,8 @@ public: Vec* Split(const IdxVec& indices) const; // Helper functions for vectors: - static zeek::VectorVal* VecToPolicy(Vec* vec); - static Vec* VecFromPolicy(zeek::VectorVal* vec); + static VectorVal* VecToPolicy(Vec* vec); + static Vec* VecFromPolicy(VectorVal* vec); static char* VecToString(const Vec* vec); protected: diff --git a/src/analyzer/Analyzer.cc b/src/analyzer/Analyzer.cc index fd114978e0..131d0cd01f 100644 --- a/src/analyzer/Analyzer.cc +++ b/src/analyzer/Analyzer.cc @@ -30,10 +30,6 @@ protected: int do_expire = 0; }; -} // namespace zeek::analyzer - -using namespace zeek::analyzer; - AnalyzerTimer::AnalyzerTimer(Analyzer* arg_analyzer, analyzer_timer_func arg_timer, double arg_t, int arg_do_expire, zeek::detail::TimerType arg_type) : Timer(arg_t, arg_type) @@ -71,7 +67,7 @@ void AnalyzerTimer::Init(Analyzer* arg_analyzer, analyzer_timer_func arg_timer, Ref(analyzer->Conn()); } -zeek::analyzer::ID Analyzer::id_counter = 0; +analyzer::ID Analyzer::id_counter = 0; const char* Analyzer::GetAnalyzerName() const { @@ -213,7 +209,7 @@ void Analyzer::Done() } void Analyzer::NextPacket(int len, const u_char* data, bool is_orig, uint64_t seq, - const zeek::IP_Hdr* ip, int caplen) + const IP_Hdr* ip, int caplen) { if ( skip ) return; @@ -231,7 +227,7 @@ void Analyzer::NextPacket(int len, const u_char* data, bool is_orig, uint64_t se } catch ( binpac::Exception const &e ) { - ProtocolViolation(zeek::util::fmt("Binpac exception: %s", e.c_msg())); + ProtocolViolation(util::fmt("Binpac exception: %s", e.c_msg())); } } } @@ -254,7 +250,7 @@ void Analyzer::NextStream(int len, const u_char* data, bool is_orig) } catch ( binpac::Exception const &e ) { - ProtocolViolation(zeek::util::fmt("Binpac exception: %s", e.c_msg())); + ProtocolViolation(util::fmt("Binpac exception: %s", e.c_msg())); } } } @@ -277,7 +273,7 @@ void Analyzer::NextUndelivered(uint64_t seq, int len, bool is_orig) } catch ( binpac::Exception const &e ) { - ProtocolViolation(zeek::util::fmt("Binpac exception: %s", e.c_msg())); + ProtocolViolation(util::fmt("Binpac exception: %s", e.c_msg())); } } } @@ -296,7 +292,7 @@ void Analyzer::NextEndOfData(bool is_orig) } void Analyzer::ForwardPacket(int len, const u_char* data, bool is_orig, - uint64_t seq, const zeek::IP_Hdr* ip, int caplen) + uint64_t seq, const IP_Hdr* ip, int caplen) { if ( output_handler ) output_handler->DeliverPacket(len, data, is_orig, seq, @@ -412,7 +408,7 @@ bool Analyzer::AddChildAnalyzer(Analyzer* analyzer, bool init) if ( init ) analyzer->Init(); - DBG_LOG(zeek::DBG_ANALYZER, "%s added child %s", + DBG_LOG(DBG_ANALYZER, "%s added child %s", fmt_analyzer(this).c_str(), fmt_analyzer(analyzer).c_str()); return true; } @@ -445,7 +441,7 @@ bool Analyzer::RemoveChild(const analyzer_list& children, ID id) if ( i->finished || i->removing ) return false; - DBG_LOG(zeek::DBG_ANALYZER, "%s disabling child %s", + DBG_LOG(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 @@ -558,7 +554,7 @@ void Analyzer::DeleteChild(analyzer_list::iterator i) child->removing = false; } - DBG_LOG(zeek::DBG_ANALYZER, "%s deleted child %s 3", + DBG_LOG(DBG_ANALYZER, "%s deleted child %s 3", fmt_analyzer(this).c_str(), fmt_analyzer(child).c_str()); children.erase(i); @@ -569,7 +565,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer) { if ( HasSupportAnalyzer(analyzer->GetAnalyzerTag(), analyzer->IsOrig()) ) { - DBG_LOG(zeek::DBG_ANALYZER, "%s already has %s %s", + DBG_LOG(DBG_ANALYZER, "%s already has %s %s", fmt_analyzer(this).c_str(), analyzer->IsOrig() ? "originator" : "responder", fmt_analyzer(analyzer).c_str()); @@ -597,7 +593,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer) analyzer->Init(); - DBG_LOG(zeek::DBG_ANALYZER, "%s added %s support %s", + DBG_LOG(DBG_ANALYZER, "%s added %s support %s", fmt_analyzer(this).c_str(), analyzer->IsOrig() ? "originator" : "responder", fmt_analyzer(analyzer).c_str()); @@ -605,7 +601,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer) void Analyzer::RemoveSupportAnalyzer(SupportAnalyzer* analyzer) { - DBG_LOG(zeek::DBG_ANALYZER, "%s disabled %s support analyzer %s", + DBG_LOG(DBG_ANALYZER, "%s disabled %s support analyzer %s", fmt_analyzer(this).c_str(), analyzer->IsOrig() ? "originator" : "responder", fmt_analyzer(analyzer).c_str()); @@ -643,35 +639,35 @@ 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) + uint64_t seq, const IP_Hdr* ip, int caplen) { - DBG_LOG(zeek::DBG_ANALYZER, "%s DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]", + DBG_LOG(DBG_ANALYZER, "%s DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]", fmt_analyzer(this).c_str(), len, is_orig ? "T" : "F", seq, ip, caplen, - zeek::util::fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : ""); + util::fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : ""); } void Analyzer::DeliverStream(int len, const u_char* data, bool is_orig) { - DBG_LOG(zeek::DBG_ANALYZER, "%s DeliverStream(%d, %s) [%s%s]", + DBG_LOG(DBG_ANALYZER, "%s DeliverStream(%d, %s) [%s%s]", fmt_analyzer(this).c_str(), len, is_orig ? "T" : "F", - zeek::util::fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : ""); + util::fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : ""); } void Analyzer::Undelivered(uint64_t seq, int len, bool is_orig) { - DBG_LOG(zeek::DBG_ANALYZER, "%s Undelivered(%" PRIu64", %d, %s)", + DBG_LOG(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(zeek::DBG_ANALYZER, "%s EndOfData(%s)", + DBG_LOG(DBG_ANALYZER, "%s EndOfData(%s)", fmt_analyzer(this).c_str(), is_orig ? "T" : "F"); } void Analyzer::FlipRoles() { - DBG_LOG(zeek::DBG_ANALYZER, "%s FlipRoles()", fmt_analyzer(this).c_str()); + DBG_LOG(DBG_ANALYZER, "%s FlipRoles()", fmt_analyzer(this).c_str()); LOOP_OVER_CHILDREN(i) (*i)->FlipRoles(); @@ -701,7 +697,7 @@ void Analyzer::ProtocolConfirmation(Tag arg_tag) return; const auto& tval = arg_tag ? arg_tag.AsVal() : tag.AsVal(); - zeek::event_mgr.Enqueue(protocol_confirmation, ConnVal(), tval, zeek::val_mgr->Count(id)); + event_mgr.Enqueue(protocol_confirmation, ConnVal(), tval, val_mgr->Count(id)); } void Analyzer::ProtocolViolation(const char* reason, const char* data, int len) @@ -709,21 +705,21 @@ void Analyzer::ProtocolViolation(const char* reason, const char* data, int len) if ( ! protocol_violation ) return; - zeek::StringValPtr r; + StringValPtr r; if ( data && len ) { - const char *tmp = zeek::util::copy_string(reason); - r = zeek::make_intrusive(zeek::util::fmt("%s [%s%s]", tmp, - zeek::util::fmt_bytes(data, min(40, len)), - len > 40 ? "..." : "")); + const char *tmp = util::copy_string(reason); + r = make_intrusive(util::fmt("%s [%s%s]", tmp, + util::fmt_bytes(data, min(40, len)), + len > 40 ? "..." : "")); delete [] tmp; } else - r = zeek::make_intrusive(reason); + r = make_intrusive(reason); const auto& tval = tag.AsVal(); - zeek::event_mgr.Enqueue(protocol_violation, ConnVal(), tval, zeek::val_mgr->Count(id), std::move(r)); + event_mgr.Enqueue(protocol_violation, ConnVal(), tval, val_mgr->Count(id), std::move(r)); } void Analyzer::AddTimer(analyzer_timer_func timer, double t, @@ -782,18 +778,18 @@ unsigned int Analyzer::MemoryAllocation() const return mem; } -void Analyzer::UpdateConnVal(zeek::RecordVal *conn_val) +void Analyzer::UpdateConnVal(RecordVal *conn_val) { LOOP_OVER_CHILDREN(i) (*i)->UpdateConnVal(conn_val); } -zeek::RecordVal* Analyzer::BuildConnVal() +RecordVal* Analyzer::BuildConnVal() { return conn->ConnVal()->Ref()->AsRecordVal(); } -const zeek::RecordValPtr& Analyzer::ConnVal() +const RecordValPtr& Analyzer::ConnVal() { return conn->ConnVal(); } @@ -803,10 +799,10 @@ void Analyzer::Event(EventHandlerPtr f, const char* name) conn->Event(f, this, name); } -void Analyzer::Event(EventHandlerPtr f, zeek::Val* v1, zeek::Val* v2) +void Analyzer::Event(EventHandlerPtr f, Val* v1, Val* v2) { - zeek::IntrusivePtr val1{zeek::AdoptRef{}, v1}; - zeek::IntrusivePtr val2{zeek::AdoptRef{}, v2}; + IntrusivePtr val1{AdoptRef{}, v1}; + IntrusivePtr val2{AdoptRef{}, v2}; if ( f ) conn->EnqueueEvent(f, this, conn->ConnVal(), std::move(val1), std::move(val2)); @@ -814,7 +810,7 @@ void Analyzer::Event(EventHandlerPtr f, zeek::Val* v1, zeek::Val* v2) void Analyzer::ConnectionEvent(EventHandlerPtr f, ValPList* vl) { - auto args = zeek::val_list_to_args(*vl); + auto args = val_list_to_args(*vl); if ( f ) conn->EnqueueEvent(f, this, std::move(args)); @@ -822,7 +818,7 @@ void Analyzer::ConnectionEvent(EventHandlerPtr f, ValPList* vl) void Analyzer::ConnectionEvent(EventHandlerPtr f, ValPList vl) { - auto args = zeek::val_list_to_args(vl); + auto args = val_list_to_args(vl); if ( f ) conn->EnqueueEvent(f, this, std::move(args)); @@ -830,11 +826,11 @@ void Analyzer::ConnectionEvent(EventHandlerPtr f, ValPList vl) void Analyzer::ConnectionEventFast(EventHandlerPtr f, ValPList vl) { - auto args = zeek::val_list_to_args(vl); + auto args = val_list_to_args(vl); conn->EnqueueEvent(f, this, std::move(args)); } -void Analyzer::EnqueueConnEvent(EventHandlerPtr f, zeek::Args args) +void Analyzer::EnqueueConnEvent(EventHandlerPtr f, Args args) { conn->EnqueueEvent(f, this, std::move(args)); } @@ -857,7 +853,7 @@ SupportAnalyzer* SupportAnalyzer::Sibling(bool only_active) const } void SupportAnalyzer::ForwardPacket(int len, const u_char* data, bool is_orig, - uint64_t seq, const zeek::IP_Hdr* ip, int caplen) + uint64_t seq, const IP_Hdr* ip, int caplen) { // We do not call parent's method, as we're replacing the functionality. @@ -925,12 +921,12 @@ void TransportLayerAnalyzer::Done() } void TransportLayerAnalyzer::SetContentsFile(unsigned int /* direction */, - zeek::FilePtr /* f */) + FilePtr /* f */) { reporter->Error("analyzer type does not support writing to a contents file"); } -zeek::FilePtr TransportLayerAnalyzer::GetContentsFile(unsigned int /* direction */) const +FilePtr TransportLayerAnalyzer::GetContentsFile(unsigned int /* direction */) const { reporter->Error("analyzer type does not support writing to a contents file"); return nullptr; @@ -940,8 +936,10 @@ void TransportLayerAnalyzer::PacketContents(const u_char* data, int len) { if ( packet_contents && len > 0 ) { - zeek::String* cbs = new zeek::String(data, len, true); - auto contents = zeek::make_intrusive(cbs); + String* cbs = new String(data, len, true); + auto contents = make_intrusive(cbs); EnqueueConnEvent(packet_contents, ConnVal(), std::move(contents)); } } + +} // namespace zeek::analyzer diff --git a/src/analyzer/Analyzer.h b/src/analyzer/Analyzer.h index 2cd150a418..e016469ab7 100644 --- a/src/analyzer/Analyzer.h +++ b/src/analyzer/Analyzer.h @@ -58,7 +58,7 @@ public: */ virtual void DeliverPacket(int len, const u_char* data, bool orig, uint64_t seq, - const zeek::IP_Hdr* ip, int caplen) + const IP_Hdr* ip, int caplen) { } /** @@ -156,7 +156,7 @@ public: * @param caplen The packet's capture length, if available. */ void NextPacket(int len, const u_char* data, bool is_orig, - uint64_t seq = -1, const zeek::IP_Hdr* ip = nullptr, int caplen = 0); + uint64_t seq = -1, const IP_Hdr* ip = nullptr, int caplen = 0); /** * Passes stream input to the analyzer for processing. The analyzer @@ -209,7 +209,7 @@ public: */ virtual void ForwardPacket(int len, const u_char* data, bool orig, uint64_t seq, - const zeek::IP_Hdr* ip, int caplen); + const IP_Hdr* ip, int caplen); /** * Forwards stream input on to all child analyzers. If the analyzer @@ -240,7 +240,7 @@ public: * Parameters are the same. */ virtual void DeliverPacket(int len, const u_char* data, bool orig, - uint64_t seq, const zeek::IP_Hdr* ip, int caplen); + uint64_t seq, const IP_Hdr* ip, int caplen); /** * Hook for accessing stream input for parsing. This is called by @@ -550,20 +550,20 @@ public: * * @param conn_val The connenction value being updated. */ - virtual void UpdateConnVal(zeek::RecordVal *conn_val); + virtual void UpdateConnVal(RecordVal *conn_val); /** * Convenience function that forwards directly to * Connection::BuildConnVal(). */ [[deprecated("Remove in v4.1. Use ConnVal() instead.")]] - zeek::RecordVal* BuildConnVal(); + RecordVal* BuildConnVal(); /** * Convenience function that forwards directly to * Connection::ConnVal(). */ - const zeek::RecordValPtr& ConnVal(); + const RecordValPtr& ConnVal(); /** * Convenience function that forwards directly to the corresponding @@ -576,7 +576,7 @@ public: * Connection::Event(). */ [[deprecated("Remove in v4.1. Use EnqueueConnEvent() instead (note it doesn't automatically ad the connection argument).")]] - void Event(EventHandlerPtr f, zeek::Val* v1, zeek::Val* v2 = nullptr); + void Event(EventHandlerPtr f, Val* v1, Val* v2 = nullptr); /** * Convenience function that forwards directly to @@ -603,7 +603,7 @@ public: * Convenience function that forwards directly to * Connection::EnqueueEvent(). */ - void EnqueueConnEvent(EventHandlerPtr f, zeek::Args args); + void EnqueueConnEvent(EventHandlerPtr f, Args args); /** * A version of EnqueueConnEvent() taking a variable number of arguments. @@ -611,7 +611,7 @@ public: template std::enable_if_t< std::is_convertible_v< - std::tuple_element_t<0, std::tuple>, zeek::ValPtr>> + std::tuple_element_t<0, std::tuple>, ValPtr>> EnqueueConnEvent(EventHandlerPtr h, Args&&... args) { return EnqueueConnEvent(h, zeek::Args{std::forward(args)...}); } @@ -637,7 +637,7 @@ protected: * and ID. */ static std::string fmt_analyzer(const Analyzer* a) - { return std::string(a->GetAnalyzerName()) + zeek::util::fmt("[%d]", a->GetID()); } + { return std::string(a->GetAnalyzerName()) + util::fmt("[%d]", a->GetID()); } /** * Associates a connection with this analyzer. Must be called if @@ -838,7 +838,7 @@ public: * Parameters same as for Analyzer::ForwardPacket. */ void ForwardPacket(int len, const u_char* data, bool orig, - uint64_t seq, const zeek::IP_Hdr* ip, int caplen) override; + uint64_t seq, const IP_Hdr* ip, int caplen) override; /** * Passes stream input to the next sibling SupportAnalyzer if any, or @@ -918,7 +918,7 @@ public: * @param f The file to record to. * */ - virtual void SetContentsFile(unsigned int direction, zeek::FilePtr f); + virtual void SetContentsFile(unsigned int direction, FilePtr f); /** * Returns an associated contents file, if any. This must only be @@ -928,20 +928,20 @@ public: * @param direction One of the CONTENTS_* constants indicating which * direction the query is for. */ - virtual zeek::FilePtr GetContentsFile(unsigned int direction) const; + virtual FilePtr GetContentsFile(unsigned int direction) const; /** * Associates a PIA with this analyzer. A PIA takes the * transport-layer input and determine which protocol analyzer(s) to * use for parsing it. */ - void SetPIA(zeek::analyzer::pia::PIA* arg_PIA) { pia = arg_PIA; } + void SetPIA(analyzer::pia::PIA* arg_PIA) { pia = arg_PIA; } /** * Returns the associated PIA, or null of none. Does not take * ownership. */ - zeek::analyzer::pia::PIA* GetPIA() const { return pia; } + analyzer::pia::PIA* GetPIA() const { return pia; } /** * Helper to raise a \c packet_contents event. @@ -953,7 +953,7 @@ public: void PacketContents(const u_char* data, int len); private: - zeek::analyzer::pia::PIA* pia; + analyzer::pia::PIA* pia; }; } // namespace zeek::analyzer diff --git a/src/analyzer/Component.cc b/src/analyzer/Component.cc index 1e0db4e105..67757c10fc 100644 --- a/src/analyzer/Component.cc +++ b/src/analyzer/Component.cc @@ -6,10 +6,10 @@ #include "../Desc.h" #include "../util.h" -using namespace zeek::analyzer; +namespace zeek::analyzer { Component::Component(const std::string& name, factory_callback arg_factory, Tag::subtype_t arg_subtype, bool arg_enabled, bool arg_partial) - : zeek::plugin::Component(zeek::plugin::component::ANALYZER, name), + : plugin::Component(plugin::component::ANALYZER, name), plugin::TaggedComponent(arg_subtype) { factory = arg_factory; @@ -20,7 +20,7 @@ Component::Component(const std::string& name, factory_callback arg_factory, Tag: void Component::Initialize() { InitializeTag(); - zeek::analyzer_mgr->RegisterComponent(this, "ANALYZER_"); + analyzer_mgr->RegisterComponent(this, "ANALYZER_"); } Component::~Component() @@ -38,3 +38,5 @@ void Component::DoDescribe(ODesc* d) const d->Add(enabled ? "enabled" : "disabled"); } + +} // namespace zeek::analyzer diff --git a/src/analyzer/Component.h b/src/analyzer/Component.h index 42498516ca..2a25738993 100644 --- a/src/analyzer/Component.h +++ b/src/analyzer/Component.h @@ -20,7 +20,7 @@ namespace zeek::analyzer { * A plugin can provide a specific protocol analyzer by registering this * analyzer component, describing the analyzer. */ -class Component : public zeek::plugin::Component, +class Component : public plugin::Component, public plugin::TaggedComponent { public: typedef Analyzer* (*factory_callback)(Connection* conn); diff --git a/src/analyzer/Manager.cc b/src/analyzer/Manager.cc index 16c9a96bad..69bb049d3d 100644 --- a/src/analyzer/Manager.cc +++ b/src/analyzer/Manager.cc @@ -18,7 +18,7 @@ #include "protocol/tcp/events.bif.h" -using namespace zeek::analyzer; +namespace zeek::analyzer { Manager::ConnIndex::ConnIndex(const IPAddr& _orig, const IPAddr& _resp, uint16_t _resp_p, uint16_t _proto) @@ -91,7 +91,7 @@ void Manager::InitPreScript() void Manager::InitPostScript() { - const auto& id = zeek::detail::global_scope()->Find("Tunnel::vxlan_ports"); + const auto& id = detail::global_scope()->Find("Tunnel::vxlan_ports"); if ( ! (id && id->GetVal()) ) reporter->FatalError("Tunnel::vxlan_ports not defined"); @@ -106,14 +106,14 @@ void Manager::InitPostScript() void Manager::DumpDebug() { #ifdef DEBUG - DBG_LOG(zeek::DBG_ANALYZER, "Available analyzers after zeek_init():"); + DBG_LOG(DBG_ANALYZER, "Available analyzers after zeek_init():"); std::list all_analyzers = GetComponents(); for ( std::list::const_iterator i = all_analyzers.begin(); i != all_analyzers.end(); ++i ) - DBG_LOG(zeek::DBG_ANALYZER, " %s (%s)", (*i)->Name().c_str(), + DBG_LOG(DBG_ANALYZER, " %s (%s)", (*i)->Name().c_str(), IsEnabled((*i)->Tag()) ? "enabled" : "disabled"); - DBG_LOG(zeek::DBG_ANALYZER, " "); - DBG_LOG(zeek::DBG_ANALYZER, "Analyzers by port:"); + DBG_LOG(DBG_ANALYZER, " "); + DBG_LOG(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++ ) { @@ -122,7 +122,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(zeek::DBG_ANALYZER, " %d/tcp: %s", i->first, s.c_str()); + DBG_LOG(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++ ) @@ -132,7 +132,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(zeek::DBG_ANALYZER, " %d/udp: %s", i->first, s.c_str()); + DBG_LOG(DBG_ANALYZER, " %d/udp: %s", i->first, s.c_str()); } #endif @@ -149,20 +149,20 @@ bool Manager::EnableAnalyzer(const Tag& tag) if ( ! p ) return false; - DBG_LOG(zeek::DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str()); + DBG_LOG(DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str()); p->SetEnabled(true); return true; } -bool Manager::EnableAnalyzer(zeek::EnumVal* val) +bool Manager::EnableAnalyzer(EnumVal* val) { Component* p = Lookup(val); if ( ! p ) return false; - DBG_LOG(zeek::DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str()); + DBG_LOG(DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str()); p->SetEnabled(true); return true; @@ -175,20 +175,20 @@ bool Manager::DisableAnalyzer(const Tag& tag) if ( ! p ) return false; - DBG_LOG(zeek::DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str()); + DBG_LOG(DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str()); p->SetEnabled(false); return true; } -bool Manager::DisableAnalyzer(zeek::EnumVal* val) +bool Manager::DisableAnalyzer(EnumVal* val) { Component* p = Lookup(val); if ( ! p ) return false; - DBG_LOG(zeek::DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str()); + DBG_LOG(DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str()); p->SetEnabled(false); return true; @@ -196,14 +196,14 @@ bool Manager::DisableAnalyzer(zeek::EnumVal* val) void Manager::DisableAllAnalyzers() { - DBG_LOG(zeek::DBG_ANALYZER, "Disabling all analyzers"); + DBG_LOG(DBG_ANALYZER, "Disabling all analyzers"); std::list all_analyzers = GetComponents(); for ( std::list::const_iterator i = all_analyzers.begin(); i != all_analyzers.end(); ++i ) (*i)->SetEnabled(false); } -zeek::analyzer::Tag Manager::GetAnalyzerTag(const char* name) +analyzer::Tag Manager::GetAnalyzerTag(const char* name) { return GetComponentTag(name); } @@ -221,7 +221,7 @@ bool Manager::IsEnabled(const Tag& tag) return p->Enabled(); } -bool Manager::IsEnabled(zeek::EnumVal* val) +bool Manager::IsEnabled(EnumVal* val) { Component* p = Lookup(val); @@ -232,7 +232,7 @@ bool Manager::IsEnabled(zeek::EnumVal* val) } -bool Manager::RegisterAnalyzerForPort(zeek::EnumVal* val, zeek::PortVal* port) +bool Manager::RegisterAnalyzerForPort(EnumVal* val, PortVal* port) { Component* p = Lookup(val); @@ -242,7 +242,7 @@ bool Manager::RegisterAnalyzerForPort(zeek::EnumVal* val, zeek::PortVal* port) return RegisterAnalyzerForPort(p->Tag(), port->PortType(), port->Port()); } -bool Manager::UnregisterAnalyzerForPort(zeek::EnumVal* val, zeek::PortVal* port) +bool Manager::UnregisterAnalyzerForPort(EnumVal* val, PortVal* port) { Component* p = Lookup(val); @@ -261,7 +261,7 @@ bool Manager::RegisterAnalyzerForPort(const Tag& tag, TransportProto proto, uint #ifdef DEBUG const char* name = GetComponentName(tag).c_str(); - DBG_LOG(zeek::DBG_ANALYZER, "Registering analyzer %s for port %" PRIu32 "/%d", name, port, proto); + DBG_LOG(DBG_ANALYZER, "Registering analyzer %s for port %" PRIu32 "/%d", name, port, proto); #endif l->insert(tag); @@ -277,7 +277,7 @@ bool Manager::UnregisterAnalyzerForPort(const Tag& tag, TransportProto proto, ui #ifdef DEBUG const char* name = GetComponentName(tag).c_str(); - DBG_LOG(zeek::DBG_ANALYZER, "Unregistering analyzer %s for port %" PRIu32 "/%d", name, port, proto); + DBG_LOG(DBG_ANALYZER, "Unregistering analyzer %s for port %" PRIu32 "/%d", name, port, proto); #endif l->erase(tag); @@ -354,36 +354,36 @@ Manager::tag_set* Manager::LookupPort(TransportProto proto, uint32_t port, bool return l; } -Manager::tag_set* Manager::LookupPort(zeek::PortVal* val, bool add_if_not_found) +Manager::tag_set* Manager::LookupPort(PortVal* val, bool add_if_not_found) { return LookupPort(val->PortType(), val->Port(), add_if_not_found); } bool Manager::BuildInitialAnalyzerTree(Connection* conn) { - zeek::analyzer::tcp::TCP_Analyzer* tcp = nullptr; + analyzer::tcp::TCP_Analyzer* tcp = nullptr; TransportLayerAnalyzer* root = nullptr; - zeek::analyzer::pia::PIA* pia = nullptr; + analyzer::pia::PIA* pia = nullptr; bool check_port = false; switch ( conn->ConnTransport() ) { case TRANSPORT_TCP: - root = tcp = new zeek::analyzer::tcp::TCP_Analyzer(conn); - pia = new zeek::analyzer::pia::PIA_TCP(conn); + root = tcp = new analyzer::tcp::TCP_Analyzer(conn); + pia = new analyzer::pia::PIA_TCP(conn); check_port = true; DBG_ANALYZER(conn, "activated TCP analyzer"); break; case TRANSPORT_UDP: - root = new zeek::analyzer::udp::UDP_Analyzer(conn); - pia = new zeek::analyzer::pia::PIA_UDP(conn); + root = new analyzer::udp::UDP_Analyzer(conn); + pia = new analyzer::pia::PIA_UDP(conn); check_port = true; DBG_ANALYZER(conn, "activated UDP analyzer"); break; case TRANSPORT_ICMP: { - root = new zeek::analyzer::icmp::ICMP_Analyzer(conn); + root = new analyzer::icmp::ICMP_Analyzer(conn); DBG_ANALYZER(conn, "activated ICMP analyzer"); break; } @@ -409,14 +409,14 @@ bool Manager::BuildInitialAnalyzerTree(Connection* conn) { for ( tag_set::const_iterator j = ports->begin(); j != ports->end(); ++j ) { - Analyzer* analyzer = zeek::analyzer_mgr->InstantiateAnalyzer(*j, conn); + Analyzer* analyzer = analyzer_mgr->InstantiateAnalyzer(*j, conn); if ( ! analyzer ) continue; root->AddChildAnalyzer(analyzer, false); DBG_ANALYZER_ARGS(conn, "activated %s analyzer due to port %d", - zeek::analyzer_mgr->GetComponentName(*j).c_str(), resp_port); + analyzer_mgr->GetComponentName(*j).c_str(), resp_port); } } } @@ -437,9 +437,9 @@ bool Manager::BuildInitialAnalyzerTree(Connection* conn) if ( tcp_contents && ! reass ) { - static auto tcp_content_delivery_ports_orig = zeek::id::find_val("tcp_content_delivery_ports_orig"); - static auto tcp_content_delivery_ports_resp = zeek::id::find_val("tcp_content_delivery_ports_resp"); - const auto& dport = zeek::val_mgr->Port(ntohs(conn->RespPort()), TRANSPORT_TCP); + static auto tcp_content_delivery_ports_orig = id::find_val("tcp_content_delivery_ports_orig"); + static auto tcp_content_delivery_ports_resp = id::find_val("tcp_content_delivery_ports_resp"); + const auto& dport = val_mgr->Port(ntohs(conn->RespPort()), TRANSPORT_TCP); if ( ! reass ) reass = (bool)tcp_content_delivery_ports_orig->FindOrDefault(dport); @@ -461,29 +461,29 @@ bool Manager::BuildInitialAnalyzerTree(Connection* conn) uint16_t resp_port = ntohs(conn->RespPort()); if ( resp_port == 22 || resp_port == 23 || resp_port == 513 ) { - static auto stp_skip_src = zeek::id::find_val("stp_skip_src"); - auto src = zeek::make_intrusive(conn->OrigAddr()); + static auto stp_skip_src = id::find_val("stp_skip_src"); + auto src = make_intrusive(conn->OrigAddr()); if ( ! stp_skip_src->FindOrDefault(src) ) - tcp->AddChildAnalyzer(new zeek::analyzer::stepping_stone::SteppingStone_Analyzer(conn), false); + tcp->AddChildAnalyzer(new analyzer::stepping_stone::SteppingStone_Analyzer(conn), false); } } if ( IsEnabled(analyzer_tcpstats) ) // Add TCPStats analyzer. This needs to see packets so // we cannot add it as a normal child. - tcp->AddChildPacketAnalyzer(new zeek::analyzer::tcp::TCPStats_Analyzer(conn)); + tcp->AddChildPacketAnalyzer(new analyzer::tcp::TCPStats_Analyzer(conn)); if ( IsEnabled(analyzer_connsize) ) // Add ConnSize analyzer. Needs to see packets, not stream. - tcp->AddChildPacketAnalyzer(new zeek::analyzer::conn_size::ConnSize_Analyzer(conn)); + tcp->AddChildPacketAnalyzer(new analyzer::conn_size::ConnSize_Analyzer(conn)); } else { if ( IsEnabled(analyzer_connsize) ) // Add ConnSize analyzer. Needs to see packets, not stream. - root->AddChildAnalyzer(new zeek::analyzer::conn_size::ConnSize_Analyzer(conn)); + root->AddChildAnalyzer(new analyzer::conn_size::ConnSize_Analyzer(conn)); } if ( pia ) @@ -500,14 +500,14 @@ bool Manager::BuildInitialAnalyzerTree(Connection* conn) void Manager::ExpireScheduledAnalyzers() { - if ( ! zeek::run_state::network_time ) + if ( ! run_state::network_time ) return; while ( conns_by_timeout.size() ) { ScheduledAnalyzer* a = conns_by_timeout.top(); - if ( a->timeout > zeek::run_state::network_time ) + if ( a->timeout > run_state::network_time ) return; conns_by_timeout.pop(); @@ -523,8 +523,8 @@ void Manager::ExpireScheduledAnalyzers() conns.erase(i); - DBG_LOG(zeek::DBG_ANALYZER, "Expiring expected analyzer %s for connection %s", - zeek::analyzer_mgr->GetComponentName(a->analyzer).c_str(), + DBG_LOG(DBG_ANALYZER, "Expiring expected analyzer %s for connection %s", + analyzer_mgr->GetComponentName(a->analyzer).c_str(), fmt_conn_id(a->conn.orig, 0, a->conn.resp, a->conn.resp_p)); delete a; @@ -541,7 +541,7 @@ void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, TransportProto proto, const Tag& analyzer, double timeout) { - if ( ! zeek::run_state::network_time ) + if ( ! run_state::network_time ) { reporter->Warning("cannot schedule analyzers before processing begins; ignored"); return; @@ -555,7 +555,7 @@ void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, ScheduledAnalyzer* a = new ScheduledAnalyzer; a->conn = ConnIndex(orig, resp, resp_p, proto); a->analyzer = analyzer; - a->timeout = zeek::run_state::network_time + timeout; + a->timeout = run_state::network_time + timeout; conns.insert(std::make_pair(a->conn, a)); conns_by_timeout.push(a); @@ -572,10 +572,10 @@ void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, ScheduleAnalyzer(orig, resp, resp_p, proto, tag, timeout); } -void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, zeek::PortVal* resp_p, - zeek::Val* analyzer, double timeout) +void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, PortVal* resp_p, + Val* analyzer, double timeout) { - zeek::EnumValPtr ev{zeek::NewRef{}, analyzer->AsEnumVal()}; + EnumValPtr ev{NewRef{}, analyzer->AsEnumVal()}; return ScheduleAnalyzer(orig, resp, resp_p->Port(), resp_p->PortType(), Tag(std::move(ev)), timeout); } @@ -598,7 +598,7 @@ Manager::tag_set Manager::GetScheduled(const Connection* conn) for ( conns_map::iterator i = all.first; i != all.second; i++ ) { - if ( i->second->timeout > zeek::run_state::network_time ) + if ( i->second->timeout > run_state::network_time ) result.insert(i->second->analyzer); } @@ -619,7 +619,7 @@ bool Manager::ApplyScheduledAnalyzers(Connection* conn, bool init, TransportLaye for ( tag_set::iterator it = expected.begin(); it != expected.end(); ++it ) { - Analyzer* analyzer = zeek::analyzer_mgr->InstantiateAnalyzer(*it, conn); + Analyzer* analyzer = analyzer_mgr->InstantiateAnalyzer(*it, conn); if ( ! analyzer ) continue; @@ -631,8 +631,10 @@ bool Manager::ApplyScheduledAnalyzers(Connection* conn, bool init, TransportLaye conn->ConnVal(), it->AsVal()); DBG_ANALYZER_ARGS(conn, "activated %s analyzer as scheduled", - zeek::analyzer_mgr->GetComponentName(*it).c_str()); + analyzer_mgr->GetComponentName(*it).c_str()); } return expected.size(); } + +} // namespace zeek::analyzer diff --git a/src/analyzer/Manager.h b/src/analyzer/Manager.h index 5ea0ed21c2..dbc439ba78 100644 --- a/src/analyzer/Manager.h +++ b/src/analyzer/Manager.h @@ -47,7 +47,7 @@ namespace analyzer { * respecting well-known ports, and tracking any analyzers specifically * scheduled for individidual connections. */ -class Manager : public zeek::plugin::ComponentManager { +class Manager : public plugin::ComponentManager { public: /** * Constructor. @@ -102,7 +102,7 @@ public: * * @return True if successful. */ - bool EnableAnalyzer(zeek::EnumVal* tag); + bool EnableAnalyzer(EnumVal* tag); /** * Enables an analyzer type. Disabled analyzers will not be @@ -123,7 +123,7 @@ public: * * @return True if successful. */ - bool DisableAnalyzer(zeek::EnumVal* tag); + bool DisableAnalyzer(EnumVal* tag); /** * Disables all currently registered analyzers. @@ -151,7 +151,7 @@ public: * @param tag The analyzer's tag as an enum of script type \c * Analyzer::Tag. */ - bool IsEnabled(zeek::EnumVal* tag); + bool IsEnabled(EnumVal* tag); /** * Registers a well-known port for an analyzer. Once registered, @@ -165,7 +165,7 @@ public: * * @return True if successful. */ - bool RegisterAnalyzerForPort(zeek::EnumVal* tag, zeek::PortVal* port); + bool RegisterAnalyzerForPort(EnumVal* tag, PortVal* port); /** * Registers a well-known port for an analyzer. Once registered, @@ -194,7 +194,7 @@ public: * registered for the analyzer). * */ - bool UnregisterAnalyzerForPort(zeek::EnumVal* tag, zeek::PortVal* port); + bool UnregisterAnalyzerForPort(EnumVal* tag, PortVal* port); /** * Unregisters a well-known port for an anlyzers. @@ -334,8 +334,8 @@ public: * @param timeout An interval after which to timeout the request to * schedule this analyzer. Must be non-zero. */ - void ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, zeek::PortVal* resp_p, - zeek::Val* analyzer, double timeout); + void ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, PortVal* resp_p, + Val* analyzer, double timeout); /** * @return the UDP port numbers to be associated with VXLAN traffic. @@ -348,7 +348,7 @@ private: using tag_set = std::set; using analyzer_map_by_port = std::map; - tag_set* LookupPort(zeek::PortVal* val, bool add_if_not_found); + tag_set* LookupPort(PortVal* val, bool add_if_not_found); tag_set* LookupPort(TransportProto proto, uint32_t port, bool add_if_not_found); tag_set GetScheduled(const Connection* conn); diff --git a/src/analyzer/Tag.cc b/src/analyzer/Tag.cc index 3c3de9dcfb..c3da63504c 100644 --- a/src/analyzer/Tag.cc +++ b/src/analyzer/Tag.cc @@ -3,33 +3,37 @@ #include "Tag.h" #include "Manager.h" -const zeek::analyzer::Tag zeek::analyzer::Tag::Error; +namespace zeek::analyzer { -zeek::analyzer::Tag::Tag(type_t type, subtype_t subtype) - : zeek::Tag(zeek::analyzer_mgr->GetTagType(), type, subtype) +const Tag Tag::Error; + +Tag::Tag(type_t type, subtype_t subtype) + : zeek::Tag(analyzer_mgr->GetTagType(), type, subtype) { } -zeek::analyzer::Tag& zeek::analyzer::Tag::operator=(const zeek::analyzer::Tag& other) +Tag& Tag::operator=(const Tag& other) { zeek::Tag::operator=(other); return *this; } -const zeek::EnumValPtr& zeek::analyzer::Tag::AsVal() const +const EnumValPtr& Tag::AsVal() const { - return zeek::Tag::AsVal(zeek::analyzer_mgr->GetTagType()); + return zeek::Tag::AsVal(analyzer_mgr->GetTagType()); } -zeek::EnumVal* zeek::analyzer::Tag::AsEnumVal() const +EnumVal* Tag::AsEnumVal() const { return AsVal().get(); } -zeek::analyzer::Tag::Tag(zeek::EnumValPtr val) +Tag::Tag(EnumValPtr val) : zeek::Tag(std::move(val)) { } -zeek::analyzer::Tag::Tag(zeek::EnumVal* val) - : zeek::Tag({zeek::NewRef{}, val}) +Tag::Tag(EnumVal* val) + : zeek::Tag({NewRef{}, val}) { } + +} // namespace zeek::analyzer diff --git a/src/analyzer/Tag.h b/src/analyzer/Tag.h index 3f9bd9ee6d..8e8325a9d3 100644 --- a/src/analyzer/Tag.h +++ b/src/analyzer/Tag.h @@ -90,17 +90,17 @@ public: * * @param etype the script-layer enum type associated with the tag. */ - const zeek::EnumValPtr& AsVal() const; + const EnumValPtr& AsVal() const; [[deprecated("Remove in v4.1. Use AsVal() instead.")]] - zeek::EnumVal* AsEnumVal() const; + EnumVal* AsEnumVal() const; static const Tag Error; protected: friend class analyzer::Manager; - friend class zeek::plugin::ComponentManager; - friend class zeek::plugin::TaggedComponent; + friend class plugin::ComponentManager; + friend class plugin::TaggedComponent; /** * Constructor. @@ -119,10 +119,10 @@ protected: * * @param val An enum value of script type \c Analyzer::Tag. */ - explicit Tag(zeek::EnumValPtr val); + explicit Tag(EnumValPtr val); [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead")]] - explicit Tag(zeek::EnumVal* val); + explicit Tag(EnumVal* val); }; } // namespace zeek::analyzer diff --git a/src/broker/Data.cc b/src/broker/Data.cc index e27f8d4b06..ebf883c975 100644 --- a/src/broker/Data.cc +++ b/src/broker/Data.cc @@ -25,8 +25,6 @@ zeek::OpaqueTypePtr& bro_broker::opaque_of_vector_iterator = zeek::Broker::detai zeek::OpaqueTypePtr zeek::Broker::detail::opaque_of_record_iterator; zeek::OpaqueTypePtr& bro_broker::opaque_of_record_iterator = zeek::Broker::detail::opaque_of_record_iterator; -static bool data_type_check(const broker::data& d, zeek::Type* t); - static broker::port::protocol to_broker_port_proto(TransportProto tp) { switch ( tp ) { @@ -52,7 +50,11 @@ TEST_CASE("converting Zeek to Broker protocol constants") broker::port::protocol::unknown); } -TransportProto zeek::Broker::detail::to_zeek_port_proto(broker::port::protocol tp) +namespace zeek::Broker::detail { + +static bool data_type_check(const broker::data& d, Type* t); + +TransportProto to_zeek_port_proto(broker::port::protocol tp) { switch ( tp ) { case broker::port::protocol::tcp: @@ -69,7 +71,6 @@ TransportProto zeek::Broker::detail::to_zeek_port_proto(broker::port::protocol t TEST_CASE("converting Broker to Zeek protocol constants") { - using zeek::Broker::detail::to_zeek_port_proto; CHECK_EQ(to_zeek_port_proto(broker::port::protocol::tcp), TRANSPORT_TCP); CHECK_EQ(to_zeek_port_proto(broker::port::protocol::udp), TRANSPORT_UDP); CHECK_EQ(to_zeek_port_proto(broker::port::protocol::icmp), TRANSPORT_ICMP); @@ -78,9 +79,9 @@ TEST_CASE("converting Broker to Zeek protocol constants") } struct val_converter { - using result_type = zeek::ValPtr; + using result_type = ValPtr; - zeek::Type* type; + Type* type; result_type operator()(broker::none) { @@ -89,43 +90,43 @@ struct val_converter { result_type operator()(bool a) { - if ( type->Tag() == zeek::TYPE_BOOL ) - return zeek::val_mgr->Bool(a); + if ( type->Tag() == TYPE_BOOL ) + return val_mgr->Bool(a); return nullptr; } result_type operator()(uint64_t a) { - if ( type->Tag() == zeek::TYPE_COUNT ) - return zeek::val_mgr->Count(a); + if ( type->Tag() == TYPE_COUNT ) + return val_mgr->Count(a); return nullptr; } result_type operator()(int64_t a) { - if ( type->Tag() == zeek::TYPE_INT ) - return zeek::val_mgr->Int(a); + if ( type->Tag() == TYPE_INT ) + return val_mgr->Int(a); return nullptr; } result_type operator()(double a) { - if ( type->Tag() == zeek::TYPE_DOUBLE ) - return zeek::make_intrusive(a); + if ( type->Tag() == TYPE_DOUBLE ) + return make_intrusive(a); return nullptr; } result_type operator()(std::string& a) { switch ( type->Tag() ) { - case zeek::TYPE_STRING: - return zeek::make_intrusive(a.size(), a.data()); - case zeek::TYPE_FILE: + case TYPE_STRING: + return make_intrusive(a.size(), a.data()); + case TYPE_FILE: { - auto file = zeek::File::Get(a.data()); + auto file = File::Get(a.data()); if ( file ) - return zeek::make_intrusive(std::move(file)); + return make_intrusive(std::move(file)); return nullptr; } @@ -136,10 +137,10 @@ struct val_converter { result_type operator()(broker::address& a) { - if ( type->Tag() == zeek::TYPE_ADDR ) + if ( type->Tag() == TYPE_ADDR ) { auto bits = reinterpret_cast(&a.bytes()); - return zeek::make_intrusive(zeek::IPAddr(*bits)); + return make_intrusive(IPAddr(*bits)); } return nullptr; @@ -147,10 +148,10 @@ struct val_converter { result_type operator()(broker::subnet& a) { - if ( type->Tag() == zeek::TYPE_SUBNET ) + if ( type->Tag() == TYPE_SUBNET ) { auto bits = reinterpret_cast(&a.network().bytes()); - return zeek::make_intrusive(zeek::IPPrefix(zeek::IPAddr(*bits), a.length())); + return make_intrusive(IPPrefix(IPAddr(*bits), a.length())); } return nullptr; @@ -158,35 +159,35 @@ struct val_converter { result_type operator()(broker::port& a) { - if ( type->Tag() == zeek::TYPE_PORT ) - return zeek::val_mgr->Port(a.number(), zeek::Broker::detail::to_zeek_port_proto(a.type())); + if ( type->Tag() == TYPE_PORT ) + return val_mgr->Port(a.number(), to_zeek_port_proto(a.type())); return nullptr; } result_type operator()(broker::timestamp& a) { - if ( type->Tag() != zeek::TYPE_TIME ) + if ( type->Tag() != TYPE_TIME ) return nullptr; using namespace std::chrono; auto s = duration_cast(a.time_since_epoch()); - return zeek::make_intrusive(s.count()); + return make_intrusive(s.count()); } result_type operator()(broker::timespan& a) { - if ( type->Tag() != zeek::TYPE_INTERVAL ) + if ( type->Tag() != TYPE_INTERVAL ) return nullptr; using namespace std::chrono; auto s = duration_cast(a); - return zeek::make_intrusive(s.count()); + return make_intrusive(s.count()); } result_type operator()(broker::enum_value& a) { - if ( type->Tag() == zeek::TYPE_ENUM ) + if ( type->Tag() == TYPE_ENUM ) { auto etype = type->AsEnumType(); auto i = etype->Lookup(zeek::detail::GLOBAL_MODULE_NAME, a.name.data()); @@ -207,7 +208,7 @@ struct val_converter { return nullptr; auto tt = type->AsTableType(); - auto rval = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, tt}); + auto rval = make_intrusive(IntrusivePtr{NewRef{}, tt}); for ( auto& item : a ) { @@ -220,8 +221,8 @@ struct val_converter { if ( expected_index_types.size() == 1 ) { auto index_is_vector_or_record = - expected_index_types[0]->Tag() == zeek::TYPE_RECORD || - expected_index_types[0]->Tag() == zeek::TYPE_VECTOR; + expected_index_types[0]->Tag() == TYPE_RECORD || + expected_index_types[0]->Tag() == TYPE_VECTOR; if ( index_is_vector_or_record ) { @@ -240,12 +241,12 @@ struct val_converter { if ( expected_index_types.size() != indices->size() ) return nullptr; - auto list_val = zeek::make_intrusive(zeek::TYPE_ANY); + auto list_val = make_intrusive(TYPE_ANY); for ( size_t i = 0; i < indices->size(); ++i ) { - auto index_val = zeek::Broker::detail::data_to_val(move((*indices)[i]), - expected_index_types[i].get()); + auto index_val = data_to_val(move((*indices)[i]), + expected_index_types[i].get()); if ( ! index_val ) return nullptr; @@ -266,7 +267,7 @@ struct val_converter { return nullptr; auto tt = type->AsTableType(); - auto rval = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, tt}); + auto rval = make_intrusive(IntrusivePtr{NewRef{}, tt}); for ( auto& item : a ) { @@ -279,8 +280,8 @@ struct val_converter { if ( expected_index_types.size() == 1 ) { auto index_is_vector_or_record = - expected_index_types[0]->Tag() == zeek::TYPE_RECORD || - expected_index_types[0]->Tag() == zeek::TYPE_VECTOR; + expected_index_types[0]->Tag() == TYPE_RECORD || + expected_index_types[0]->Tag() == TYPE_VECTOR; if ( index_is_vector_or_record ) { @@ -299,12 +300,12 @@ struct val_converter { if ( expected_index_types.size() != indices->size() ) return nullptr; - auto list_val = zeek::make_intrusive(zeek::TYPE_ANY); + auto list_val = make_intrusive(TYPE_ANY); for ( size_t i = 0; i < indices->size(); ++i ) { - auto index_val = zeek::Broker::detail::data_to_val(move((*indices)[i]), - expected_index_types[i].get()); + auto index_val = data_to_val(move((*indices)[i]), + expected_index_types[i].get()); if ( ! index_val ) return nullptr; @@ -312,8 +313,8 @@ struct val_converter { list_val->Append(std::move(index_val)); } - auto value_val = zeek::Broker::detail::data_to_val(move(item.second), - tt->Yield().get()); + auto value_val = data_to_val(move(item.second), + tt->Yield().get()); if ( ! value_val ) return nullptr; @@ -326,14 +327,14 @@ struct val_converter { result_type operator()(broker::vector& a) { - if ( type->Tag() == zeek::TYPE_VECTOR ) + if ( type->Tag() == TYPE_VECTOR ) { auto vt = type->AsVectorType(); - auto rval = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, vt}); + auto rval = make_intrusive(IntrusivePtr{NewRef{}, vt}); for ( auto& item : a ) { - auto item_val = zeek::Broker::detail::data_to_val(move(item), vt->Yield().get()); + auto item_val = data_to_val(move(item), vt->Yield().get()); if ( ! item_val ) return nullptr; @@ -343,7 +344,7 @@ struct val_converter { return rval; } - else if ( type->Tag() == zeek::TYPE_FUNC ) + else if ( type->Tag() == TYPE_FUNC ) { if ( a.size() < 1 || a.size() > 2 ) return nullptr; @@ -364,7 +365,7 @@ struct val_converter { if ( ! t ) return nullptr; - if ( t->Tag() != zeek::TYPE_FUNC ) + if ( t->Tag() != TYPE_FUNC ) return nullptr; if ( a.size() == 2 ) // We have a closure. @@ -383,10 +384,10 @@ struct val_converter { return rval; } - else if ( type->Tag() == zeek::TYPE_RECORD ) + else if ( type->Tag() == TYPE_RECORD ) { auto rt = type->AsRecordType(); - auto rval = zeek::make_intrusive(zeek::IntrusivePtr{zeek::NewRef{}, rt}); + auto rval = make_intrusive(IntrusivePtr{NewRef{}, rt}); auto idx = 0u; for ( size_t i = 0; i < static_cast(rt->NumFields()); ++i ) @@ -401,8 +402,7 @@ struct val_converter { continue; } - auto item_val = zeek::Broker::detail::data_to_val(move(a[idx]), - rt->GetFieldType(i).get()); + auto item_val = data_to_val(move(a[idx]), rt->GetFieldType(i).get()); if ( ! item_val ) return nullptr; @@ -413,7 +413,7 @@ struct val_converter { return rval; } - else if ( type->Tag() == zeek::TYPE_PATTERN ) + else if ( type->Tag() == TYPE_PATTERN ) { if ( a.size() != 2 ) return nullptr; @@ -424,22 +424,22 @@ struct val_converter { if ( ! exact_text || ! anywhere_text ) return nullptr; - auto* re = new zeek::RE_Matcher(exact_text->c_str(), - anywhere_text->c_str()); + auto* re = new RE_Matcher(exact_text->c_str(), + anywhere_text->c_str()); if ( ! re->Compile() ) { - zeek::reporter->Error("failed compiling unserialized pattern: %s, %s", - exact_text->c_str(), anywhere_text->c_str()); + reporter->Error("failed compiling unserialized pattern: %s, %s", + exact_text->c_str(), anywhere_text->c_str()); delete re; return nullptr; } - auto rval = zeek::make_intrusive(re); + auto rval = make_intrusive(re); return rval; } - else if ( type->Tag() == zeek::TYPE_OPAQUE ) - return zeek::OpaqueVal::Unserialize(a); + else if ( type->Tag() == TYPE_OPAQUE ) + return OpaqueVal::Unserialize(a); return nullptr; } @@ -448,7 +448,7 @@ struct val_converter { struct type_checker { using result_type = bool; - zeek::Type* type; + Type* type; result_type operator()(broker::none) { @@ -457,28 +457,28 @@ struct type_checker { result_type operator()(bool a) { - if ( type->Tag() == zeek::TYPE_BOOL ) + if ( type->Tag() == TYPE_BOOL ) return true; return false; } result_type operator()(uint64_t a) { - if ( type->Tag() == zeek::TYPE_COUNT ) + if ( type->Tag() == TYPE_COUNT ) return true; return false; } result_type operator()(int64_t a) { - if ( type->Tag() == zeek::TYPE_INT ) + if ( type->Tag() == TYPE_INT ) return true; return false; } result_type operator()(double a) { - if ( type->Tag() == zeek::TYPE_DOUBLE ) + if ( type->Tag() == TYPE_DOUBLE ) return true; return false; } @@ -486,9 +486,9 @@ struct type_checker { result_type operator()(const std::string& a) { switch ( type->Tag() ) { - case zeek::TYPE_STRING: + case TYPE_STRING: return true; - case zeek::TYPE_FILE: + case TYPE_FILE: return true; default: return false; @@ -497,7 +497,7 @@ struct type_checker { result_type operator()(const broker::address& a) { - if ( type->Tag() == zeek::TYPE_ADDR ) + if ( type->Tag() == TYPE_ADDR ) return true; return false; @@ -505,7 +505,7 @@ struct type_checker { result_type operator()(const broker::subnet& a) { - if ( type->Tag() == zeek::TYPE_SUBNET ) + if ( type->Tag() == TYPE_SUBNET ) return true; return false; @@ -513,7 +513,7 @@ struct type_checker { result_type operator()(const broker::port& a) { - if ( type->Tag() == zeek::TYPE_PORT ) + if ( type->Tag() == TYPE_PORT ) return true; return false; @@ -521,7 +521,7 @@ struct type_checker { result_type operator()(const broker::timestamp& a) { - if ( type->Tag() == zeek::TYPE_TIME ) + if ( type->Tag() == TYPE_TIME ) return true; return false; @@ -529,7 +529,7 @@ struct type_checker { result_type operator()(const broker::timespan& a) { - if ( type->Tag() == zeek::TYPE_INTERVAL ) + if ( type->Tag() == TYPE_INTERVAL ) return true; return false; @@ -537,7 +537,7 @@ struct type_checker { result_type operator()(const broker::enum_value& a) { - if ( type->Tag() == zeek::TYPE_ENUM ) + if ( type->Tag() == TYPE_ENUM ) { auto etype = type->AsEnumType(); auto i = etype->Lookup(zeek::detail::GLOBAL_MODULE_NAME, a.name.data()); @@ -565,8 +565,8 @@ struct type_checker { if ( expected_index_types.size() == 1 ) { auto index_is_vector_or_record = - expected_index_types[0]->Tag() == zeek::TYPE_RECORD || - expected_index_types[0]->Tag() == zeek::TYPE_VECTOR; + expected_index_types[0]->Tag() == TYPE_RECORD || + expected_index_types[0]->Tag() == TYPE_VECTOR; if ( index_is_vector_or_record ) // Disambiguate from composite key w/ multiple vals. @@ -624,8 +624,8 @@ struct type_checker { if ( expected_index_types.size() == 1 ) { auto index_is_vector_or_record = - expected_index_types[0]->Tag() == zeek::TYPE_RECORD || - expected_index_types[0]->Tag() == zeek::TYPE_VECTOR; + expected_index_types[0]->Tag() == TYPE_RECORD || + expected_index_types[0]->Tag() == TYPE_VECTOR; if ( index_is_vector_or_record ) // Disambiguate from composite key w/ multiple vals. @@ -673,7 +673,7 @@ struct type_checker { result_type operator()(const broker::vector& a) { - if ( type->Tag() == zeek::TYPE_VECTOR ) + if ( type->Tag() == TYPE_VECTOR ) { auto vt = type->AsVectorType(); @@ -685,7 +685,7 @@ struct type_checker { return true; } - else if ( type->Tag() == zeek::TYPE_FUNC ) + else if ( type->Tag() == TYPE_FUNC ) { if ( a.size() < 1 || a.size() > 2 ) return false; @@ -706,12 +706,12 @@ struct type_checker { if ( ! t ) return false; - if ( t->Tag() != zeek::TYPE_FUNC ) + if ( t->Tag() != TYPE_FUNC ) return false; return true; } - else if ( type->Tag() == zeek::TYPE_RECORD ) + else if ( type->Tag() == TYPE_RECORD ) { auto rt = type->AsRecordType(); auto idx = 0u; @@ -735,7 +735,7 @@ struct type_checker { return true; } - else if ( type->Tag() == zeek::TYPE_PATTERN ) + else if ( type->Tag() == TYPE_PATTERN ) { if ( a.size() != 2 ) return false; @@ -746,25 +746,25 @@ struct type_checker { if ( ! exact_text || ! anywhere_text ) return false; - auto* re = new zeek::RE_Matcher(exact_text->c_str(), - anywhere_text->c_str()); + auto* re = new RE_Matcher(exact_text->c_str(), + anywhere_text->c_str()); auto compiled = re->Compile(); delete re; if ( ! compiled ) { - zeek::reporter->Error("failed compiling pattern: %s, %s", - exact_text->c_str(), anywhere_text->c_str()); + reporter->Error("failed compiling pattern: %s, %s", + exact_text->c_str(), anywhere_text->c_str()); return false; } return true; } - else if ( type->Tag() == zeek::TYPE_OPAQUE ) + else if ( type->Tag() == TYPE_OPAQUE ) { // TODO: Could avoid doing the full unserialization here // and just check if the type is a correct match. - auto ov = zeek::OpaqueVal::Unserialize(a); + auto ov = OpaqueVal::Unserialize(a); return ov != nullptr; } @@ -772,37 +772,37 @@ struct type_checker { } }; -static bool data_type_check(const broker::data& d, zeek::Type* t) +static bool data_type_check(const broker::data& d, Type* t) { - if ( t->Tag() == zeek::TYPE_ANY ) + if ( t->Tag() == TYPE_ANY ) return true; return caf::visit(type_checker{t}, d); } -zeek::ValPtr zeek::Broker::detail::data_to_val(broker::data d, zeek::Type* type) +ValPtr data_to_val(broker::data d, Type* type) { - if ( type->Tag() == zeek::TYPE_ANY ) - return zeek::Broker::detail::make_data_val(move(d)); + if ( type->Tag() == TYPE_ANY ) + return make_data_val(move(d)); return caf::visit(val_converter{type}, std::move(d)); } -broker::expected zeek::Broker::detail::val_to_data(const zeek::Val* v) +broker::expected val_to_data(const Val* v) { switch ( v->GetType()->Tag() ) { - case zeek::TYPE_BOOL: + case TYPE_BOOL: return {v->AsBool()}; - case zeek::TYPE_INT: + case TYPE_INT: return {v->AsInt()}; - case zeek::TYPE_COUNT: + case TYPE_COUNT: return {v->AsCount()}; - case zeek::TYPE_PORT: + case TYPE_PORT: { auto p = v->AsPortVal(); return {broker::port(p->Port(), to_broker_port_proto(p->PortType()))}; } - case zeek::TYPE_ADDR: + case TYPE_ADDR: { auto a = v->AsAddr(); in6_addr tmp; @@ -812,7 +812,7 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val broker::address::byte_order::network)}; } break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { auto s = v->AsSubNet(); in6_addr tmp; @@ -823,35 +823,35 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val return {broker::subnet(std::move(a), s.Length())}; } break; - case zeek::TYPE_DOUBLE: + case TYPE_DOUBLE: return {v->AsDouble()}; - case zeek::TYPE_TIME: + case TYPE_TIME: { auto secs = broker::fractional_seconds{v->AsTime()}; auto since_epoch = std::chrono::duration_cast(secs); return {broker::timestamp{since_epoch}}; } - case zeek::TYPE_INTERVAL: + case TYPE_INTERVAL: { auto secs = broker::fractional_seconds{v->AsInterval()}; return {std::chrono::duration_cast(secs)}; } - case zeek::TYPE_ENUM: + case TYPE_ENUM: { auto enum_type = v->GetType()->AsEnumType(); auto enum_name = enum_type->Lookup(v->AsEnum()); return {broker::enum_value(enum_name ? enum_name : "")}; } - case zeek::TYPE_STRING: + case TYPE_STRING: { auto s = v->AsString(); return {string(reinterpret_cast(s->Bytes()), s->Len())}; } - case zeek::TYPE_FILE: + case TYPE_FILE: return {string(v->AsFile()->Name())}; - case zeek::TYPE_FUNC: + case TYPE_FUNC: { - const zeek::Func* f = v->AsFunc(); + const Func* f = v->AsFunc(); std::string name(f->Name()); broker::vector rval; @@ -870,14 +870,14 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val } else { - zeek::reporter->InternalWarning("Closure with non-ScriptFunc"); + reporter->InternalWarning("Closure with non-ScriptFunc"); return broker::ec::invalid_data; } } return {std::move(rval)}; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { auto is_set = v->GetType()->IsSet(); auto table = v->AsTable(); @@ -890,7 +890,7 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val rval = broker::table(); zeek::detail::HashKey* hk; - zeek::TableEntryVal* entry; + TableEntryVal* entry; auto c = table->InitForIteration(); while ( (entry = table->NextEntry(hk, c)) ) @@ -933,7 +933,7 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val return {std::move(rval)}; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { auto vec = v->AsVectorVal(); broker::vector rval; @@ -956,7 +956,7 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val return {std::move(rval)}; } - case zeek::TYPE_RECORD: + case TYPE_RECORD: { auto rec = v->AsRecordVal(); broker::vector rval; @@ -983,123 +983,123 @@ broker::expected zeek::Broker::detail::val_to_data(const zeek::Val return {std::move(rval)}; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { - const zeek::RE_Matcher* p = v->AsPattern(); + const RE_Matcher* p = v->AsPattern(); broker::vector rval = {p->PatternText(), p->AnywherePatternText()}; return {std::move(rval)}; } - case zeek::TYPE_OPAQUE: + case TYPE_OPAQUE: { auto c = v->AsOpaqueVal()->Serialize(); if ( ! c ) { - zeek::reporter->Error("unsupported opaque type for serialization"); + reporter->Error("unsupported opaque type for serialization"); break; } return {c}; } default: - zeek::reporter->Error("unsupported Broker::Data type: %s", - zeek::type_name(v->GetType()->Tag())); + reporter->Error("unsupported Broker::Data type: %s", + type_name(v->GetType()->Tag())); break; } return broker::ec::invalid_data; } -zeek::RecordValPtr zeek::Broker::detail::make_data_val(zeek::Val* v) +RecordValPtr make_data_val(Val* v) { - auto rval = zeek::make_intrusive(zeek::BifType::Record::Broker::Data); + auto rval = make_intrusive(BifType::Record::Broker::Data); auto data = val_to_data(v); if ( data ) - rval->Assign(0, zeek::make_intrusive(move(*data))); + rval->Assign(0, make_intrusive(move(*data))); else - zeek::reporter->Warning("did not get a value from val_to_data"); + reporter->Warning("did not get a value from val_to_data"); return rval; } -zeek::RecordValPtr zeek::Broker::detail::make_data_val(broker::data d) +RecordValPtr make_data_val(broker::data d) { - auto rval = zeek::make_intrusive(zeek::BifType::Record::Broker::Data); - rval->Assign(0, zeek::make_intrusive(move(d))); + auto rval = make_intrusive(BifType::Record::Broker::Data); + rval->Assign(0, make_intrusive(move(d))); return rval; } struct data_type_getter { - using result_type = zeek::EnumValPtr; + using result_type = EnumValPtr; result_type operator()(broker::none) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::NONE); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::NONE); } result_type operator()(bool) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::BOOL); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::BOOL); } result_type operator()(uint64_t) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::COUNT); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::COUNT); } result_type operator()(int64_t) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INT); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INT); } result_type operator()(double) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::DOUBLE); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::DOUBLE); } result_type operator()(const std::string&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::STRING); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::STRING); } result_type operator()(const broker::address&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ADDR); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ADDR); } result_type operator()(const broker::subnet&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SUBNET); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SUBNET); } result_type operator()(const broker::port&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::PORT); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::PORT); } result_type operator()(const broker::timestamp&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TIME); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TIME); } result_type operator()(const broker::timespan&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INTERVAL); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INTERVAL); } result_type operator()(const broker::enum_value&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ENUM); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ENUM); } result_type operator()(const broker::set&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SET); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SET); } result_type operator()(const broker::table&) { - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TABLE); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TABLE); } result_type operator()(const broker::vector&) @@ -1107,21 +1107,21 @@ struct data_type_getter { // Note that Broker uses vectors to store record data, so there's // no actual way to tell if this data was originally associated // with a Bro record. - return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::VECTOR); + return BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::VECTOR); } }; -zeek::EnumValPtr zeek::Broker::detail::get_data_type(zeek::RecordVal* v, zeek::detail::Frame* frame) +EnumValPtr get_data_type(RecordVal* v, zeek::detail::Frame* frame) { return caf::visit(data_type_getter{}, opaque_field_to_data(v, frame)); } -broker::data& zeek::Broker::detail::opaque_field_to_data(zeek::RecordVal* v, zeek::detail::Frame* f) +broker::data& opaque_field_to_data(RecordVal* v, zeek::detail::Frame* f) { const auto& d = v->GetField(0); if ( ! d ) - zeek::reporter->RuntimeError(f->GetCall()->GetLocationInfo(), + reporter->RuntimeError(f->GetCall()->GetLocationInfo(), "Broker::Data's opaque field is not set"); // RuntimeError throws an exception which causes this line to never exceute. @@ -1129,37 +1129,37 @@ broker::data& zeek::Broker::detail::opaque_field_to_data(zeek::RecordVal* v, zee return static_cast(d.get())->data; } -void zeek::Broker::detail::DataVal::ValDescribe(zeek::ODesc* d) const +void DataVal::ValDescribe(ODesc* d) const { d->Add("broker::data{"); d->Add(broker::to_string(data)); d->Add("}"); } -bool zeek::Broker::detail::DataVal::canCastTo(zeek::Type* t) const +bool DataVal::canCastTo(zeek::Type* t) const { return data_type_check(data, t); } -zeek::ValPtr zeek::Broker::detail::DataVal::castTo(zeek::Type* t) +ValPtr DataVal::castTo(zeek::Type* t) { return data_to_val(data, t); } -const zeek::TypePtr& zeek::Broker::detail::DataVal::ScriptDataType() +const TypePtr& DataVal::ScriptDataType() { - static auto script_data_type = zeek::id::find_type("Broker::Data"); + static auto script_data_type = id::find_type("Broker::Data"); return script_data_type; } IMPLEMENT_OPAQUE_VALUE(zeek::Broker::detail::DataVal) -broker::expected zeek::Broker::detail::DataVal::DoSerialize() const +broker::expected DataVal::DoSerialize() const { return data; } -bool zeek::Broker::detail::DataVal::DoUnserialize(const broker::data& data_) +bool DataVal::DoUnserialize(const broker::data& data_) { data = data_; return true; @@ -1167,12 +1167,12 @@ bool zeek::Broker::detail::DataVal::DoUnserialize(const broker::data& data_) IMPLEMENT_OPAQUE_VALUE(zeek::Broker::detail::SetIterator) -broker::expected zeek::Broker::detail::SetIterator::DoSerialize() const +broker::expected SetIterator::DoSerialize() const { return broker::vector{dat, *it}; } -bool zeek::Broker::detail::SetIterator::DoUnserialize(const broker::data& data) +bool SetIterator::DoUnserialize(const broker::data& data) { auto v = caf::get_if(&data); if ( ! (v && v->size() == 2) ) @@ -1194,12 +1194,12 @@ bool zeek::Broker::detail::SetIterator::DoUnserialize(const broker::data& data) IMPLEMENT_OPAQUE_VALUE(zeek::Broker::detail::TableIterator) -broker::expected zeek::Broker::detail::TableIterator::DoSerialize() const +broker::expected TableIterator::DoSerialize() const { return broker::vector{dat, it->first}; } -bool zeek::Broker::detail::TableIterator::DoUnserialize(const broker::data& data) +bool TableIterator::DoUnserialize(const broker::data& data) { auto v = caf::get_if(&data); if ( ! (v && v->size() == 2) ) @@ -1221,13 +1221,13 @@ bool zeek::Broker::detail::TableIterator::DoUnserialize(const broker::data& data IMPLEMENT_OPAQUE_VALUE(zeek::Broker::detail::VectorIterator) -broker::expected zeek::Broker::detail::VectorIterator::DoSerialize() const +broker::expected VectorIterator::DoSerialize() const { broker::integer difference = it - dat.begin(); return broker::vector{dat, difference}; } -bool zeek::Broker::detail::VectorIterator::DoUnserialize(const broker::data& data) +bool VectorIterator::DoUnserialize(const broker::data& data) { auto v = caf::get_if(&data); if ( ! (v && v->size() == 2) ) @@ -1246,13 +1246,13 @@ bool zeek::Broker::detail::VectorIterator::DoUnserialize(const broker::data& dat IMPLEMENT_OPAQUE_VALUE(zeek::Broker::detail::RecordIterator) -broker::expected zeek::Broker::detail::RecordIterator::DoSerialize() const +broker::expected RecordIterator::DoSerialize() const { broker::integer difference = it - dat.begin(); return broker::vector{dat, difference}; } -bool zeek::Broker::detail::RecordIterator::DoUnserialize(const broker::data& data) +bool RecordIterator::DoUnserialize(const broker::data& data) { auto v = caf::get_if(&data); if ( ! (v && v->size() == 2) ) @@ -1269,7 +1269,7 @@ bool zeek::Broker::detail::RecordIterator::DoUnserialize(const broker::data& dat return true; } -broker::data zeek::Broker::detail::threading_field_to_data(const zeek::threading::Field* f) +broker::data threading_field_to_data(const threading::Field* f) { auto name = f->name; auto type = static_cast(f->type); @@ -1284,7 +1284,7 @@ broker::data zeek::Broker::detail::threading_field_to_data(const zeek::threading return broker::vector({name, secondary, type, subtype, optional}); } -zeek::threading::Field* zeek::Broker::detail::data_to_threading_field(broker::data d) +threading::Field* data_to_threading_field(broker::data d) { if ( ! caf::holds_alternative(d) ) return nullptr; @@ -1302,9 +1302,11 @@ zeek::threading::Field* zeek::Broker::detail::data_to_threading_field(broker::da if ( secondary != broker::nil && ! caf::holds_alternative(secondary) ) return nullptr; - return new zeek::threading::Field(name->c_str(), - secondary != broker::nil ? caf::get(secondary).c_str() : nullptr, - static_cast(*type), - static_cast(*subtype), - *optional); + return new threading::Field(name->c_str(), + secondary != broker::nil ? caf::get(secondary).c_str() : nullptr, + static_cast(*type), + static_cast(*subtype), + *optional); } + +} // namespace zeek::Broker::detail diff --git a/src/broker/Data.h b/src/broker/Data.h index 2970c84f75..009bbf35c5 100644 --- a/src/broker/Data.h +++ b/src/broker/Data.h @@ -17,11 +17,11 @@ namespace threading { namespace zeek::Broker::detail { -extern zeek::OpaqueTypePtr opaque_of_data_type; -extern zeek::OpaqueTypePtr opaque_of_set_iterator; -extern zeek::OpaqueTypePtr opaque_of_table_iterator; -extern zeek::OpaqueTypePtr opaque_of_vector_iterator; -extern zeek::OpaqueTypePtr opaque_of_record_iterator; +extern OpaqueTypePtr opaque_of_data_type; +extern OpaqueTypePtr opaque_of_set_iterator; +extern OpaqueTypePtr opaque_of_table_iterator; +extern OpaqueTypePtr opaque_of_vector_iterator; +extern OpaqueTypePtr opaque_of_record_iterator; /** * Convert a broker port protocol to a zeek port protocol. @@ -34,14 +34,14 @@ TransportProto to_zeek_port_proto(broker::port::protocol tp); * @return a Broker::Data value, where the optional field is set if the conversion * was possible, else it is unset. */ -zeek::RecordValPtr make_data_val(zeek::Val* v); +RecordValPtr make_data_val(Val* v); /** * Create a Broker::Data value from a Broker data value. * @param d the Broker value to wrap in an opaque type. * @return a Broker::Data value that wraps the Broker value. */ -zeek::RecordValPtr make_data_val(broker::data d); +RecordValPtr make_data_val(broker::data d); /** * Get the type of Broker data that Broker::Data wraps. @@ -49,14 +49,14 @@ zeek::RecordValPtr make_data_val(broker::data d); * @param frame used to get location info upon error. * @return a Broker::DataType value. */ -zeek::EnumValPtr get_data_type(zeek::RecordVal* v, zeek::detail::Frame* frame); +EnumValPtr get_data_type(RecordVal* v, zeek::detail::Frame* frame); /** * Convert a Bro value to a Broker data value. * @param v a Bro value. * @return a Broker data value if the Bro value could be converted to one. */ -broker::expected val_to_data(const zeek::Val* v); +broker::expected val_to_data(const Val* v); /** * Convert a Broker data value to a Bro value. @@ -65,14 +65,14 @@ broker::expected val_to_data(const zeek::Val* v); * @return a pointer to a new Bro value or a nullptr if the conversion was not * possible. */ -zeek::ValPtr data_to_val(broker::data d, zeek::Type* type); +ValPtr data_to_val(broker::data d, Type* type); /** * Convert a zeek::threading::Field to a Broker data value. * @param f a zeek::threading::Field. * @return a Broker data value if the zeek::threading::Field could be converted to one. */ -broker::data threading_field_to_data(const zeek::threading::Field* f); +broker::data threading_field_to_data(const threading::Field* f); /** * Convert a Broker data value to a zeek::threading::Value. @@ -80,33 +80,33 @@ broker::data threading_field_to_data(const zeek::threading::Field* f); * @return a pointer to a new zeek::threading::Value or a nullptr if the conversion was not * possible. */ -zeek::threading::Field* data_to_threading_field(broker::data d); +threading::Field* data_to_threading_field(broker::data d); /** * A Bro value which wraps a Broker data value. */ -class DataVal : public zeek::OpaqueVal { +class DataVal : public OpaqueVal { public: DataVal(broker::data arg_data) - : OpaqueVal(zeek::Broker::detail::opaque_of_data_type), data(std::move(arg_data)) + : OpaqueVal(opaque_of_data_type), data(std::move(arg_data)) {} - void ValDescribe(zeek::ODesc* d) const override; + void ValDescribe(ODesc* d) const override; - zeek::ValPtr castTo(zeek::Type* t); + ValPtr castTo(zeek::Type* t); bool canCastTo(zeek::Type* t) const; // Returns the Bro type that scripts use to represent a Broker data // instance. This may be wrapping the opaque value inside another // type. - static const zeek::TypePtr& ScriptDataType(); + static const TypePtr& ScriptDataType(); broker::data data; protected: DataVal() - : OpaqueVal(zeek::Broker::detail::opaque_of_data_type) + : OpaqueVal(opaque_of_data_type) {} DECLARE_OPAQUE_VALUE(zeek::Broker::detail::DataVal) @@ -216,7 +216,7 @@ class SetIterator : public zeek::OpaqueVal { public: SetIterator(zeek::RecordVal* v, zeek::TypeTag tag, zeek::detail::Frame* f) - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_set_iterator), + : zeek::OpaqueVal(opaque_of_set_iterator), dat(require_data_type(v, zeek::TYPE_TABLE, f)), it(dat.begin()) {} @@ -226,7 +226,7 @@ public: protected: SetIterator() - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_set_iterator) + : zeek::OpaqueVal(opaque_of_set_iterator) {} DECLARE_OPAQUE_VALUE(zeek::Broker::detail::SetIterator) @@ -236,7 +236,7 @@ class TableIterator : public zeek::OpaqueVal { public: TableIterator(zeek::RecordVal* v, zeek::TypeTag tag, zeek::detail::Frame* f) - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_table_iterator), + : zeek::OpaqueVal(opaque_of_table_iterator), dat(require_data_type(v, zeek::TYPE_TABLE, f)), it(dat.begin()) {} @@ -246,7 +246,7 @@ public: protected: TableIterator() - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_table_iterator) + : zeek::OpaqueVal(opaque_of_table_iterator) {} DECLARE_OPAQUE_VALUE(zeek::Broker::detail::TableIterator) @@ -256,7 +256,7 @@ class VectorIterator : public zeek::OpaqueVal { public: VectorIterator(zeek::RecordVal* v, zeek::TypeTag tag, zeek::detail::Frame* f) - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_vector_iterator), + : zeek::OpaqueVal(opaque_of_vector_iterator), dat(require_data_type(v, zeek::TYPE_VECTOR, f)), it(dat.begin()) {} @@ -266,7 +266,7 @@ public: protected: VectorIterator() - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_vector_iterator) + : zeek::OpaqueVal(opaque_of_vector_iterator) {} DECLARE_OPAQUE_VALUE(zeek::Broker::detail::VectorIterator) @@ -276,7 +276,7 @@ class RecordIterator : public zeek::OpaqueVal { public: RecordIterator(zeek::RecordVal* v, zeek::TypeTag tag, zeek::detail::Frame* f) - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_record_iterator), + : zeek::OpaqueVal(opaque_of_record_iterator), dat(require_data_type(v, zeek::TYPE_RECORD, f)), it(dat.begin()) {} @@ -286,7 +286,7 @@ public: protected: RecordIterator() - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_record_iterator) + : zeek::OpaqueVal(opaque_of_record_iterator) {} DECLARE_OPAQUE_VALUE(zeek::Broker::detail::RecordIterator) diff --git a/src/broker/Manager.cc b/src/broker/Manager.cc index 2f3b87ec83..e8cd4420c2 100644 --- a/src/broker/Manager.cc +++ b/src/broker/Manager.cc @@ -28,12 +28,12 @@ using namespace std; namespace zeek::Broker { -static inline zeek::Val* get_option(const char* option) +static inline Val* get_option(const char* option) { const auto& id = zeek::detail::global_scope()->Find(option); if ( ! (id && id->GetVal()) ) - zeek::reporter->FatalError("Unknown Broker option %s", option); + reporter->FatalError("Unknown Broker option %s", option); return id->GetVal().get(); } @@ -72,29 +72,29 @@ int Manager::script_scope = 0; struct scoped_reporter_location { scoped_reporter_location(zeek::detail::Frame* frame) { - zeek::reporter->PushLocation(frame->GetCall()->GetLocationInfo()); + reporter->PushLocation(frame->GetCall()->GetLocationInfo()); } ~scoped_reporter_location() { - zeek::reporter->PopLocation(); + reporter->PopLocation(); } }; #ifdef DEBUG static std::string RenderMessage(std::string topic, const broker::data& x) { - return zeek::util::fmt("%s -> %s", broker::to_string(x).c_str(), topic.c_str()); + return util::fmt("%s -> %s", broker::to_string(x).c_str(), topic.c_str()); } static std::string RenderEvent(std::string topic, std::string name, const broker::data& args) { - return zeek::util::fmt("%s(%s) -> %s", name.c_str(), broker::to_string(args).c_str(), topic.c_str()); + return util::fmt("%s(%s) -> %s", name.c_str(), broker::to_string(args).c_str(), topic.c_str()); } static std::string RenderMessage(const broker::store::response& x) { - return zeek::util::fmt("%s [id %" PRIu64 "]", (x.answer ? broker::to_string(*x.answer).c_str() : ""), x.id); + return util::fmt("%s [id %" PRIu64 "]", (x.answer ? broker::to_string(*x.answer).c_str() : ""), x.id); } static std::string RenderMessage(const broker::vector* xs) @@ -119,7 +119,7 @@ static std::string RenderMessage(const broker::status& s) static std::string RenderMessage(const broker::error& e) { - return zeek::util::fmt("%s (%s)", broker::to_string(e.code()).c_str(), + return util::fmt("%s (%s)", broker::to_string(e.code()).c_str(), caf::to_string(e.context()).c_str()); } @@ -143,27 +143,27 @@ Manager::~Manager() void Manager::InitPostScript() { - DBG_LOG(zeek::DBG_BROKER, "Initializing"); + DBG_LOG(DBG_BROKER, "Initializing"); log_batch_size = get_option("Broker::log_batch_size")->AsCount(); default_log_topic_prefix = get_option("Broker::default_log_topic_prefix")->AsString()->CheckString(); log_topic_func = get_option("Broker::log_topic")->AsFunc(); - log_id_type = zeek::id::find_type("Log::ID")->AsEnumType(); - writer_id_type = zeek::id::find_type("Log::Writer")->AsEnumType(); + log_id_type = id::find_type("Log::ID")->AsEnumType(); + writer_id_type = id::find_type("Log::Writer")->AsEnumType(); zeek_table_manager = get_option("Broker::table_store_master")->AsBool(); zeek_table_db_directory = get_option("Broker::table_store_db_directory")->AsString()->CheckString(); - detail::opaque_of_data_type = zeek::make_intrusive("Broker::Data"); - detail::opaque_of_set_iterator = zeek::make_intrusive("Broker::SetIterator"); - detail::opaque_of_table_iterator = zeek::make_intrusive("Broker::TableIterator"); - detail::opaque_of_vector_iterator = zeek::make_intrusive("Broker::VectorIterator"); - detail::opaque_of_record_iterator = zeek::make_intrusive("Broker::RecordIterator"); - detail::opaque_of_store_handle = zeek::make_intrusive("Broker::Store"); - vector_of_data_type = zeek::make_intrusive(zeek::id::find_type("Broker::Data")); + detail::opaque_of_data_type = make_intrusive("Broker::Data"); + detail::opaque_of_set_iterator = make_intrusive("Broker::SetIterator"); + detail::opaque_of_table_iterator = make_intrusive("Broker::TableIterator"); + detail::opaque_of_vector_iterator = make_intrusive("Broker::VectorIterator"); + detail::opaque_of_record_iterator = make_intrusive("Broker::RecordIterator"); + detail::opaque_of_store_handle = make_intrusive("Broker::Store"); + vector_of_data_type = make_intrusive(id::find_type("Broker::Data")); // Register as a "dont-count" source first, we may change that later. - zeek::iosource_mgr->Register(this, true); + iosource_mgr->Register(this, true); broker::broker_options options; options.disable_ssl = get_option("Broker::disable_ssl")->AsBool(); @@ -174,14 +174,14 @@ void Manager::InitPostScript() auto scheduler_policy = get_option("Broker::scheduler_policy")->AsString()->CheckString(); - if ( zeek::util::streq(scheduler_policy, "sharing") ) + if ( util::streq(scheduler_policy, "sharing") ) config.set("scheduler.policy", caf::atom("sharing")); - else if ( zeek::util::streq(scheduler_policy, "stealing") ) + else if ( util::streq(scheduler_policy, "stealing") ) config.set("scheduler.policy", caf::atom("stealing")); else - zeek::reporter->FatalError("Invalid Broker::scheduler_policy: %s", scheduler_policy); + reporter->FatalError("Invalid Broker::scheduler_policy: %s", scheduler_policy); - auto max_threads_env = zeek::util::zeekenv("ZEEK_BROKER_MAX_THREADS"); + auto max_threads_env = util::zeekenv("ZEEK_BROKER_MAX_THREADS"); if ( max_threads_env ) config.set("scheduler.max-threads", atoi(max_threads_env)); @@ -210,10 +210,10 @@ void Manager::InitPostScript() auto cqs = get_option("Broker::congestion_queue_size")->AsCount(); bstate = std::make_shared(std::move(config), cqs); - if ( ! zeek::iosource_mgr->RegisterFd(bstate->subscriber.fd(), this) ) - zeek::reporter->FatalError("Failed to register broker subscriber with iosource_mgr"); - if ( ! zeek::iosource_mgr->RegisterFd(bstate->status_subscriber.fd(), this) ) - zeek::reporter->FatalError("Failed to register broker status subscriber with iosource_mgr"); + if ( ! iosource_mgr->RegisterFd(bstate->subscriber.fd(), this) ) + reporter->FatalError("Failed to register broker subscriber with iosource_mgr"); + if ( ! iosource_mgr->RegisterFd(bstate->status_subscriber.fd(), this) ) + reporter->FatalError("Failed to register broker status subscriber with iosource_mgr"); bstate->subscriber.add_topic(broker::topics::store_events, true); @@ -233,7 +233,7 @@ void Manager::InitializeBrokerStoreForwarding() auto e = static_cast(attr->GetExpr()->Eval(nullptr)->AsEnum()); auto storename = std::string("___sync_store_") + global.first; id->GetVal()->AsTableVal()->SetBrokerStore(storename); - AddForwardedStore(storename, zeek::cast_intrusive(id->GetVal())); + AddForwardedStore(storename, cast_intrusive(id->GetVal())); // We only create masters here. For clones, we do all the work of setting up // the forwarding - but we do not try to initialize the clone. We can only initialize @@ -268,8 +268,8 @@ void Manager::Terminate() { FlushLogBuffers(); - zeek::iosource_mgr->UnregisterFd(bstate->subscriber.fd(), this); - zeek::iosource_mgr->UnregisterFd(bstate->status_subscriber.fd(), this); + iosource_mgr->UnregisterFd(bstate->subscriber.fd(), this); + iosource_mgr->UnregisterFd(bstate->status_subscriber.fd(), this); vector stores_to_close; @@ -353,9 +353,9 @@ uint16_t Manager::Listen(const string& addr, uint16_t port) addr.empty() ? "INADDR_ANY" : addr.c_str(), port); // Register as a "does-count" source now. - zeek::iosource_mgr->Register(this, false); + iosource_mgr->Register(this, false); - DBG_LOG(zeek::DBG_BROKER, "Listening on %s:%" PRIu16, + DBG_LOG(DBG_BROKER, "Listening on %s:%" PRIu16, addr.empty() ? "INADDR_ANY" : addr.c_str(), port); return bound_port; @@ -366,10 +366,10 @@ void Manager::Peer(const string& addr, uint16_t port, double retry) if ( bstate->endpoint.is_shutdown() ) return; - DBG_LOG(zeek::DBG_BROKER, "Starting to peer with %s:%" PRIu16, + DBG_LOG(DBG_BROKER, "Starting to peer with %s:%" PRIu16, addr.c_str(), port); - auto e = zeek::util::zeekenv("ZEEK_DEFAULT_CONNECT_RETRY"); + auto e = util::zeekenv("ZEEK_DEFAULT_CONNECT_RETRY"); if ( e ) retry = atoi(e); @@ -385,7 +385,7 @@ void Manager::Peer(const string& addr, uint16_t port, double retry) if ( counts_as_iosource ) // Register as a "does-count" source now. - zeek::iosource_mgr->Register(this, false); + iosource_mgr->Register(this, false); } void Manager::Unpeer(const string& addr, uint16_t port) @@ -393,7 +393,7 @@ void Manager::Unpeer(const string& addr, uint16_t port) if ( bstate->endpoint.is_shutdown() ) return; - DBG_LOG(zeek::DBG_BROKER, "Stopping to peer with %s:%" PRIu16, + DBG_LOG(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(zeek::DBG_BROKER, "Publishing event: %s", + DBG_LOG(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()); @@ -429,7 +429,7 @@ bool Manager::PublishEvent(string topic, std::string name, broker::vector args) return true; } -bool Manager::PublishEvent(string topic, zeek::RecordVal* args) +bool Manager::PublishEvent(string topic, RecordVal* args) { if ( bstate->endpoint.is_shutdown() ) return true; @@ -480,21 +480,21 @@ bool Manager::PublishIdentifier(std::string topic, std::string id) if ( ! data ) { Error("Failed to publish ID with unsupported type: %s (%s)", - id.c_str(), zeek::type_name(val->GetType()->Tag())); + id.c_str(), type_name(val->GetType()->Tag())); return false; } broker::zeek::IdentifierUpdate msg(move(id), move(*data)); - DBG_LOG(zeek::DBG_BROKER, "Publishing id-update: %s", + DBG_LOG(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; return true; } -bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer, - const zeek::logging::WriterBackend::WriterInfo& info, - int num_fields, const zeek::threading::Field* const * fields, +bool Manager::PublishLogCreate(EnumVal* stream, EnumVal* writer, + const logging::WriterBackend::WriterInfo& info, + int num_fields, const threading::Field* const * fields, const broker::endpoint_info& peer) { if ( bstate->endpoint.is_shutdown() ) @@ -507,8 +507,8 @@ bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer, if ( ! stream_id ) { - zeek::reporter->Error("Failed to remotely log: stream %d doesn't have name", - stream->AsEnum()); + reporter->Error("Failed to remotely log: stream %d doesn't have name", + stream->AsEnum()); return false; } @@ -516,8 +516,8 @@ bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer, if ( ! writer_id ) { - zeek::reporter->Error("Failed to remotely log: writer %d doesn't have name", - writer->AsEnum()); + reporter->Error("Failed to remotely log: writer %d doesn't have name", + writer->AsEnum()); return false; } @@ -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(zeek::DBG_BROKER, "Publishing log creation: %s", RenderMessage(topic, msg.as_data()).c_str()); + DBG_LOG(DBG_BROKER, "Publishing log creation: %s", RenderMessage(topic, msg.as_data()).c_str()); if ( peer.node != NoPeer.node ) // Direct message. @@ -549,8 +549,8 @@ bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer, return true; } -bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, string path, - int num_fields, const zeek::threading::Value* const * vals) +bool Manager::PublishLogWrite(EnumVal* stream, EnumVal* writer, string path, + int num_fields, const threading::Value* const * vals) { if ( bstate->endpoint.is_shutdown() ) return true; @@ -563,8 +563,8 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri if ( ! stream_id ) { - zeek::reporter->Error("Failed to remotely log: stream %d doesn't have name", - stream->AsEnum()); + reporter->Error("Failed to remotely log: stream %d doesn't have name", + stream->AsEnum()); return false; } @@ -572,8 +572,8 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri if ( ! writer_id ) { - zeek::reporter->Error("Failed to remotely log: writer %d doesn't have name", - writer->AsEnum()); + reporter->Error("Failed to remotely log: writer %d doesn't have name", + writer->AsEnum()); return false; } @@ -587,7 +587,7 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri if ( ! success ) { - zeek::reporter->Error("Failed to remotely log stream %s: num_fields serialization failed", stream_id); + reporter->Error("Failed to remotely log stream %s: num_fields serialization failed", stream_id); return false; } @@ -595,7 +595,7 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri { if ( ! vals[i]->Write(&fmt) ) { - zeek::reporter->Error("Failed to remotely log stream %s: field %d serialization failed", stream_id, i); + reporter->Error("Failed to remotely log stream %s: field %d serialization failed", stream_id, i); return false; } } @@ -604,14 +604,14 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri std::string serial_data(data, len); free(data); - auto v = log_topic_func->Invoke(zeek::IntrusivePtr{zeek::NewRef{}, stream}, - zeek::make_intrusive(path)); + auto v = log_topic_func->Invoke(IntrusivePtr{NewRef{}, stream}, + make_intrusive(path)); if ( ! v ) { - zeek::reporter->Error("Failed to remotely log: log_topic func did not return" - " a value for stream %s at path %s", stream_id, - path.data()); + reporter->Error("Failed to remotely log: log_topic func did not return" + " a value for stream %s at path %s", stream_id, + path.data()); return false; } @@ -620,9 +620,9 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri auto bstream_id = broker::enum_value(move(stream_id)); auto bwriter_id = broker::enum_value(move(writer_id)); broker::zeek::LogWrite msg(move(bstream_id), move(bwriter_id), move(path), - move(serial_data)); + move(serial_data)); - DBG_LOG(zeek::DBG_BROKER, "Buffering log record: %s", RenderMessage(topic, msg.as_data()).c_str()); + DBG_LOG(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(zeek::DBG_BROKER, "Flushing all log buffers"); + DBG_LOG(DBG_BROKER, "Flushing all log buffers"); auto rval = 0u; for ( auto& lb : log_buffers ) @@ -679,31 +679,31 @@ void Manager::Error(const char* format, ...) { va_list args; va_start(args, format); - auto msg = zeek::util::vfmt(format, args); + auto msg = util::vfmt(format, args); va_end(args); if ( script_scope ) - zeek::emit_builtin_error(msg); + emit_builtin_error(msg); else - zeek::reporter->Error("%s", msg); + reporter->Error("%s", msg); } -bool Manager::AutoPublishEvent(string topic, zeek::Val* event) +bool Manager::AutoPublishEvent(string topic, Val* event) { - if ( event->GetType()->Tag() != zeek::TYPE_FUNC ) + if ( event->GetType()->Tag() != TYPE_FUNC ) { Error("Broker::auto_publish must operate on an event"); return false; } auto event_val = event->AsFunc(); - if ( event_val->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( event_val->Flavor() != FUNC_FLAVOR_EVENT ) { Error("Broker::auto_publish must operate on an event"); return false; } - auto handler = zeek::event_registry->Lookup(event_val->Name()); + auto handler = event_registry->Lookup(event_val->Name()); if ( ! handler ) { Error("Broker::auto_publish failed to lookup event '%s'", @@ -711,15 +711,15 @@ bool Manager::AutoPublishEvent(string topic, zeek::Val* event) return false; } - DBG_LOG(zeek::DBG_BROKER, "Enabling auto-publising of event %s to topic %s", handler->Name(), topic.c_str()); + DBG_LOG(DBG_BROKER, "Enabling auto-publising of event %s to topic %s", handler->Name(), topic.c_str()); handler->AutoPublish(move(topic)); return true; } -bool Manager::AutoUnpublishEvent(const string& topic, zeek::Val* event) +bool Manager::AutoUnpublishEvent(const string& topic, Val* event) { - if ( event->GetType()->Tag() != zeek::TYPE_FUNC ) + if ( event->GetType()->Tag() != TYPE_FUNC ) { Error("Broker::auto_event_stop must operate on an event"); return false; @@ -727,13 +727,13 @@ bool Manager::AutoUnpublishEvent(const string& topic, zeek::Val* event) auto event_val = event->AsFunc(); - if ( event_val->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( event_val->Flavor() != FUNC_FLAVOR_EVENT ) { Error("Broker::auto_event_stop must operate on an event"); return false; } - auto handler = zeek::event_registry->Lookup(event_val->Name()); + auto handler = event_registry->Lookup(event_val->Name()); if ( ! handler ) { @@ -743,18 +743,18 @@ bool Manager::AutoUnpublishEvent(const string& topic, zeek::Val* event) } - DBG_LOG(zeek::DBG_BROKER, "Disabling auto-publishing of event %s to topic %s", handler->Name(), topic.c_str()); + DBG_LOG(DBG_BROKER, "Disabling auto-publishing of event %s to topic %s", handler->Name(), topic.c_str()); handler->AutoUnpublish(topic); return true; } -zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) +RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) { - auto rval = new zeek::RecordVal(zeek::BifType::Record::Broker::Event); - auto arg_vec = zeek::make_intrusive(vector_of_data_type); + auto rval = new RecordVal(BifType::Record::Broker::Event); + auto arg_vec = make_intrusive(vector_of_data_type); rval->Assign(1, arg_vec); - zeek::Func* func = nullptr; + Func* func = nullptr; scoped_reporter_location srl{frame}; for ( auto i = 0; i < args->length(); ++i ) @@ -765,7 +765,7 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) { // Event val must come first. - if ( arg_val->GetType()->Tag() != zeek::TYPE_FUNC ) + if ( arg_val->GetType()->Tag() != TYPE_FUNC ) { Error("attempt to convert non-event into an event type"); return rval; @@ -773,7 +773,7 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) func = arg_val->AsFunc(); - if ( func->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( func->Flavor() != FUNC_FLAVOR_EVENT ) { Error("attempt to convert non-event into an event type"); return rval; @@ -788,7 +788,7 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) return rval; } - rval->Assign(0, zeek::make_intrusive(func->Name())); + rval->Assign(0, make_intrusive(func->Name())); continue; } @@ -799,15 +799,15 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) { rval->Assign(0, nullptr); Error("event parameter #%d type mismatch, got %s, expect %s", i, - zeek::type_name(got_type->Tag()), - zeek::type_name(expected_type->Tag())); + type_name(got_type->Tag()), + type_name(expected_type->Tag())); return rval; } - zeek::RecordValPtr data_val; + RecordValPtr data_val; if ( same_type(got_type, detail::DataVal::ScriptDataType()) ) - data_val = {zeek::NewRef{}, (*args)[i]->AsRecordVal()}; + data_val = {NewRef{}, (*args)[i]->AsRecordVal()}; else data_val = detail::make_data_val((*args)[i]); @@ -815,7 +815,7 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) { rval->Assign(0, nullptr); Error("failed to convert param #%d of type %s to broker data", - i, zeek::type_name(got_type->Tag())); + i, type_name(got_type->Tag())); return rval; } @@ -827,7 +827,7 @@ zeek::RecordVal* Manager::MakeEvent(ValPList* args, zeek::detail::Frame* frame) bool Manager::Subscribe(const string& topic_prefix) { - DBG_LOG(zeek::DBG_BROKER, "Subscribing to topic prefix %s", topic_prefix.c_str()); + DBG_LOG(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(zeek::DBG_BROKER, "Forwarding topic prefix %s", topic_prefix.c_str()); + DBG_LOG(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(zeek::DBG_BROKER, "Unforwading topic prefix %s", topic_prefix.c_str()); + DBG_LOG(DBG_BROKER, "Unforwading topic prefix %s", topic_prefix.c_str()); forwarded_prefixes.erase(forwarded_prefixes.begin() + i); break; } - DBG_LOG(zeek::DBG_BROKER, "Unsubscribing from topic prefix %s", topic_prefix.c_str()); + DBG_LOG(DBG_BROKER, "Unsubscribing from topic prefix %s", topic_prefix.c_str()); bstate->subscriber.remove_topic(topic_prefix, ! after_zeek_init); return true; } @@ -872,8 +872,8 @@ void Manager::DispatchMessage(const broker::topic& topic, broker::data msg) { switch ( broker::zeek::Message::type(msg) ) { case broker::zeek::Message::Type::Invalid: - zeek::reporter->Warning("received invalid broker message: %s", - broker::to_string(msg).data()); + reporter->Warning("received invalid broker message: %s", + broker::to_string(msg).data()); break; case broker::zeek::Message::Type::Event: @@ -898,8 +898,8 @@ void Manager::DispatchMessage(const broker::topic& topic, broker::data msg) if ( ! batch.valid() ) { - zeek::reporter->Warning("received invalid broker Batch: %s", - broker::to_string(batch).data()); + reporter->Warning("received invalid broker Batch: %s", + broker::to_string(batch).data()); return; } @@ -912,8 +912,8 @@ void Manager::DispatchMessage(const broker::topic& topic, broker::data msg) default: // We ignore unknown types so that we could add more in the // future if we had too. - zeek::reporter->Warning("received unknown broker message: %s", - broker::to_string(msg).data()); + reporter->Warning("received unknown broker message: %s", + broker::to_string(msg).data()); break; } } @@ -923,7 +923,7 @@ void Manager::Process() // Ensure that time gets update before processing broker messages, or events // based on them might get scheduled wrong. if ( use_real_time ) - zeek::run_state::detail::update_network_time(zeek::util::current_time()); + run_state::detail::update_network_time(util::current_time()); bool had_input = false; @@ -945,7 +945,7 @@ void Manager::Process() continue; } - zeek::reporter->InternalWarning("ignoring status_subscriber message with unexpected type"); + reporter->InternalWarning("ignoring status_subscriber message with unexpected type"); } auto messages = bstate->subscriber.poll(); @@ -974,7 +974,7 @@ void Manager::Process() } catch ( std::runtime_error& e ) { - zeek::reporter->Warning("ignoring invalid Broker message: %s", + e.what()); + reporter->Warning("ignoring invalid Broker message: %s", + e.what()); continue; } } @@ -995,15 +995,15 @@ void Manager::Process() if ( had_input ) { - if ( zeek::run_state::network_time == 0 ) + if ( run_state::network_time == 0 ) // If we're getting Broker messages, but still haven't initialized - // zeek::run_state::network_time, may as well do so now because otherwise the + // run_state::network_time, may as well do so now because otherwise the // broker/cluster logs will end up using timestamp 0. - zeek::run_state::detail::update_network_time(zeek::util::current_time()); + run_state::detail::update_network_time(util::current_time()); } } -void Manager::ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table, +void Manager::ProcessStoreEventInsertUpdate(const TableValPtr& table, const std::string& store_id, const broker::data& key, const broker::data& data, @@ -1016,16 +1016,16 @@ void Manager::ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table, if ( insert ) { - 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()); + 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()); } else { - 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()); + 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()); } if ( table->GetType()->IsSet() && data.get_type() != broker::data::type::none ) { - zeek::reporter->Error("ProcessStoreEvent %s got %s when expecting set", type, data.get_type_name()); + reporter->Error("ProcessStoreEvent %s got %s when expecting set", type, data.get_type_name()); return; } @@ -1034,7 +1034,7 @@ void Manager::ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table, auto zeek_key = detail::data_to_val(key, its[0].get()); if ( ! zeek_key ) { - zeek::reporter->Error("ProcessStoreEvent %s: could not convert key \"%s\" for store \"%s\" while receiving remote data. This probably means the tables have different types on different nodes.", type, to_string(key).c_str(), store_id.c_str()); + reporter->Error("ProcessStoreEvent %s: could not convert key \"%s\" for store \"%s\" while receiving remote data. This probably means the tables have different types on different nodes.", type, to_string(key).c_str(), store_id.c_str()); return; } @@ -1048,7 +1048,7 @@ void Manager::ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table, auto zeek_value = detail::data_to_val(data, table->GetType()->Yield().get()); if ( ! zeek_value ) { - zeek::reporter->Error("ProcessStoreEvent %s: could not convert value \"%s\" for key \"%s\" in store \"%s\" while receiving remote data. This probably means the tables have different types on different nodes.", type, to_string(data).c_str(), to_string(key).c_str(), store_id.c_str()); + reporter->Error("ProcessStoreEvent %s: could not convert value \"%s\" for key \"%s\" in store \"%s\" while receiving remote data. This probably means the tables have different types on different nodes.", type, to_string(data).c_str(), to_string(key).c_str(), store_id.c_str()); return; } @@ -1104,13 +1104,13 @@ void Manager::ProcessStoreEvent(broker::data msg) return; auto key = erase.key(); - DBG_LOG(zeek::DBG_BROKER, "Store %s: Erase key %s", erase.store_id().c_str(), to_string(key).c_str()); + DBG_LOG(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 = detail::data_to_val(key, its[0].get()); if ( ! zeek_key ) { - zeek::reporter->Error("ProcessStoreEvent: could not convert key \"%s\" for store \"%s\" while receiving remote erase. This probably means the tables have different types on different nodes.", to_string(key).c_str(), insert.store_id().c_str()); + reporter->Error("ProcessStoreEvent: could not convert key \"%s\" for store \"%s\" while receiving remote erase. This probably means the tables have different types on different nodes.", to_string(key).c_str(), insert.store_id().c_str()); return; } @@ -1129,12 +1129,12 @@ void Manager::ProcessStoreEvent(broker::data msg) if ( ! table ) return; - DBG_LOG(zeek::DBG_BROKER, "Store %s: Store expired key %s", expire.store_id().c_str(), to_string(expire.key()).c_str()); + DBG_LOG(DBG_BROKER, "Store %s: Store expired key %s", expire.store_id().c_str(), to_string(expire.key()).c_str()); #endif /* DEBUG */ } else { - zeek::reporter->Error("ProcessStoreEvent: Unhandled event type"); + reporter->Error("ProcessStoreEvent: Unhandled event type"); } } @@ -1142,18 +1142,18 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev) { if ( ! ev.valid() ) { - zeek::reporter->Warning("received invalid broker Event: %s", - broker::to_string(ev.as_data()).data()); + reporter->Warning("received invalid broker Event: %s", + broker::to_string(ev.as_data()).data()); return; } auto name = std::move(ev.name()); auto args = std::move(ev.args()); - DBG_LOG(zeek::DBG_BROKER, "Process event: %s %s", + DBG_LOG(DBG_BROKER, "Process event: %s %s", name.data(), RenderMessage(args).data()); ++statistics.num_events_incoming; - auto handler = zeek::event_registry->Lookup(name); + auto handler = event_registry->Lookup(name); if ( ! handler ) return; @@ -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(zeek::DBG_BROKER, "Skip processing of forwarded event: %s %s", + DBG_LOG(DBG_BROKER, "Skip processing of forwarded event: %s %s", name.data(), RenderMessage(args).data()); return; } @@ -1177,13 +1177,13 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev) if ( arg_types.size() != args.size() ) { - zeek::reporter->Warning("got event message '%s' with invalid # of args," - " got %zd, expected %zu", name.data(), args.size(), - arg_types.size()); + reporter->Warning("got event message '%s' with invalid # of args," + " got %zd, expected %zu", name.data(), args.size(), + arg_types.size()); return; } - zeek::Args vl; + Args vl; vl.reserve(args.size()); for ( size_t i = 0; i < args.size(); ++i ) @@ -1196,18 +1196,18 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev) vl.emplace_back(std::move(val)); else { - auto expected_name = zeek::type_name(expected_type->Tag()); + auto expected_name = type_name(expected_type->Tag()); - zeek::reporter->Warning("failed to convert remote event '%s' arg #%zu," - " got %s, expected %s", - name.data(), i, got_type, - expected_name); + reporter->Warning("failed to convert remote event '%s' arg #%zu," + " got %s, expected %s", + name.data(), i, got_type, + expected_name); // If we got a vector and expected a function this is // possibly because of a mismatch between // anonymous-function bodies. if ( strcmp(expected_name, "func") == 0 && strcmp("vector", got_type) == 0 ) - zeek::reporter->Warning( + reporter->Warning( "when sending functions the receiver must have access to a" " version of that function.\nFor anonymous functions, that function must have the same body."); @@ -1216,37 +1216,37 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev) } if ( vl.size() == args.size() ) - zeek::event_mgr.Enqueue(handler, std::move(vl), zeek::util::detail::SOURCE_BROKER); + event_mgr.Enqueue(handler, std::move(vl), util::detail::SOURCE_BROKER); } bool Manager::ProcessLogCreate(broker::zeek::LogCreate lc) { - DBG_LOG(zeek::DBG_BROKER, "Received log-create: %s", RenderMessage(lc.as_data()).c_str()); + DBG_LOG(DBG_BROKER, "Received log-create: %s", RenderMessage(lc.as_data()).c_str()); if ( ! lc.valid() ) { - zeek::reporter->Warning("received invalid broker LogCreate: %s", - broker::to_string(lc).data()); + reporter->Warning("received invalid broker LogCreate: %s", + broker::to_string(lc).data()); return false; } auto stream_id = detail::data_to_val(std::move(lc.stream_id()), log_id_type); if ( ! stream_id ) { - zeek::reporter->Warning("failed to unpack remote log stream id"); + reporter->Warning("failed to unpack remote log stream id"); return false; } auto writer_id = detail::data_to_val(std::move(lc.writer_id()), writer_id_type); if ( ! writer_id ) { - zeek::reporter->Warning("failed to unpack remote log writer id"); + reporter->Warning("failed to unpack remote log writer id"); return false; } - auto writer_info = std::make_unique(); + auto writer_info = std::make_unique(); if ( ! writer_info->FromBroker(std::move(lc.writer_info())) ) { - zeek::reporter->Warning("failed to unpack remote log writer info"); + reporter->Warning("failed to unpack remote log writer info"); return false; } @@ -1255,12 +1255,12 @@ bool Manager::ProcessLogCreate(broker::zeek::LogCreate lc) if ( ! fields_data ) { - zeek::reporter->Warning("failed to unpack remote log fields"); + reporter->Warning("failed to unpack remote log fields"); return false; } auto num_fields = fields_data->size(); - auto fields = new zeek::threading::Field* [num_fields]; + auto fields = new threading::Field* [num_fields]; for ( size_t i = 0; i < num_fields; ++i ) { @@ -1268,17 +1268,17 @@ bool Manager::ProcessLogCreate(broker::zeek::LogCreate lc) fields[i] = field; else { - zeek::reporter->Warning("failed to convert remote log field # %zu", i); + reporter->Warning("failed to convert remote log field # %zu", i); delete [] fields; return false; } } - if ( ! zeek::log_mgr->CreateWriterForRemoteLog(stream_id->AsEnumVal(), writer_id->AsEnumVal(), writer_info.release(), num_fields, fields) ) + if ( ! log_mgr->CreateWriterForRemoteLog(stream_id->AsEnumVal(), writer_id->AsEnumVal(), writer_info.release(), num_fields, fields) ) { - zeek::ODesc d; + ODesc d; stream_id->Describe(&d); - zeek::reporter->Warning("failed to create remote log stream for %s locally", d.Description()); + reporter->Warning("failed to create remote log stream for %s locally", d.Description()); } return true; @@ -1286,11 +1286,11 @@ bool Manager::ProcessLogCreate(broker::zeek::LogCreate lc) bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) { - DBG_LOG(zeek::DBG_BROKER, "Received log-write: %s", RenderMessage(lw.as_data()).c_str()); + DBG_LOG(DBG_BROKER, "Received log-write: %s", RenderMessage(lw.as_data()).c_str()); if ( ! lw.valid() ) { - zeek::reporter->Warning("received invalid broker LogWrite: %s", + reporter->Warning("received invalid broker LogWrite: %s", broker::to_string(lw).data()); return false; } @@ -1303,8 +1303,8 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) if ( ! stream_id ) { - zeek::reporter->Warning("failed to unpack remote log stream id: %s", - stream_id_name.data()); + reporter->Warning("failed to unpack remote log stream id: %s", + stream_id_name.data()); return false; } @@ -1312,7 +1312,7 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) auto writer_id = detail::data_to_val(std::move(lw.writer_id()), writer_id_type); if ( ! writer_id ) { - zeek::reporter->Warning("failed to unpack remote log writer id for stream: %s", stream_id_name.data()); + reporter->Warning("failed to unpack remote log writer id for stream: %s", stream_id_name.data()); return false; } @@ -1320,7 +1320,7 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) if ( ! path ) { - zeek::reporter->Warning("failed to unpack remote log values (bad path variant) for stream: %s", stream_id_name.data()); + reporter->Warning("failed to unpack remote log values (bad path variant) for stream: %s", stream_id_name.data()); return false; } @@ -1328,7 +1328,7 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) if ( ! serial_data ) { - zeek::reporter->Warning("failed to unpack remote log values (bad serial_data variant) for stream: %s", stream_id_name.data()); + reporter->Warning("failed to unpack remote log values (bad serial_data variant) for stream: %s", stream_id_name.data()); return false; } @@ -1340,15 +1340,15 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) if ( ! success ) { - zeek::reporter->Warning("failed to unserialize remote log num fields for stream: %s", stream_id_name.data()); + reporter->Warning("failed to unserialize remote log num fields for stream: %s", stream_id_name.data()); return false; } - auto vals = new zeek::threading::Value* [num_fields]; + auto vals = new threading::Value* [num_fields]; for ( int i = 0; i < num_fields; ++i ) { - vals[i] = new zeek::threading::Value; + vals[i] = new threading::Value; if ( ! vals[i]->Read(&fmt) ) { @@ -1356,13 +1356,13 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) delete vals[j]; delete [] vals; - zeek::reporter->Warning("failed to unserialize remote log field %d for stream: %s", i, stream_id_name.data()); + reporter->Warning("failed to unserialize remote log field %d for stream: %s", i, stream_id_name.data()); return false; } } - zeek::log_mgr->WriteFromRemote(stream_id->AsEnumVal(), writer_id->AsEnumVal(), + log_mgr->WriteFromRemote(stream_id->AsEnumVal(), writer_id->AsEnumVal(), std::move(*path), num_fields, vals); fmt.EndRead(); return true; @@ -1370,12 +1370,12 @@ bool Manager::ProcessLogWrite(broker::zeek::LogWrite lw) bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu) { - DBG_LOG(zeek::DBG_BROKER, "Received id-update: %s", RenderMessage(iu.as_data()).c_str()); + DBG_LOG(DBG_BROKER, "Received id-update: %s", RenderMessage(iu.as_data()).c_str()); if ( ! iu.valid() ) { - zeek::reporter->Warning("received invalid broker IdentifierUpdate: %s", - broker::to_string(iu).data()); + reporter->Warning("received invalid broker IdentifierUpdate: %s", + broker::to_string(iu).data()); return false; } @@ -1386,8 +1386,8 @@ bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu) if ( ! id ) { - zeek::reporter->Warning("Received id-update request for unkown id: %s", - id_name.c_str()); + reporter->Warning("Received id-update request for unkown id: %s", + id_name.c_str()); return false; } @@ -1395,8 +1395,8 @@ bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu) if ( ! val ) { - zeek::reporter->Error("Failed to receive ID with unsupported type: %s (%s)", - id_name.c_str(), zeek::type_name(id->GetType()->Tag())); + reporter->Error("Failed to receive ID with unsupported type: %s (%s)", + id_name.c_str(), type_name(id->GetType()->Tag())); return false; } @@ -1406,11 +1406,11 @@ bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu) void Manager::ProcessStatus(broker::status stat) { - DBG_LOG(zeek::DBG_BROKER, "Received status message: %s", RenderMessage(stat).c_str()); + DBG_LOG(DBG_BROKER, "Received status message: %s", RenderMessage(stat).c_str()); auto ctx = stat.context(); - zeek::EventHandlerPtr event; + EventHandlerPtr event; switch (stat.code()) { case broker::sc::unspecified: event = ::Broker::status; @@ -1419,7 +1419,7 @@ void Manager::ProcessStatus(broker::status stat) case broker::sc::peer_added: ++peer_count; assert(ctx); - zeek::log_mgr->SendAllWritersTo(*ctx); + log_mgr->SendAllWritersTo(*ctx); event = ::Broker::peer_added; break; @@ -1434,47 +1434,47 @@ void Manager::ProcessStatus(broker::status stat) break; default: - zeek::reporter->Warning("Unhandled Broker status: %s", to_string(stat).data()); + reporter->Warning("Unhandled Broker status: %s", to_string(stat).data()); break; } if ( ! event ) return; - static auto ei = zeek::id::find_type("Broker::EndpointInfo"); - auto endpoint_info = zeek::make_intrusive(ei); + static auto ei = id::find_type("Broker::EndpointInfo"); + auto endpoint_info = make_intrusive(ei); if ( ctx ) { - endpoint_info->Assign(0, zeek::make_intrusive(to_string(ctx->node))); - static auto ni = zeek::id::find_type("Broker::NetworkInfo"); - auto network_info = zeek::make_intrusive(ni); + endpoint_info->Assign(0, make_intrusive(to_string(ctx->node))); + static auto ni = id::find_type("Broker::NetworkInfo"); + auto network_info = make_intrusive(ni); if ( ctx->network ) { - network_info->Assign(0, zeek::make_intrusive(ctx->network->address.data())); - network_info->Assign(1, zeek::val_mgr->Port(ctx->network->port, TRANSPORT_TCP)); + network_info->Assign(0, make_intrusive(ctx->network->address.data())); + network_info->Assign(1, val_mgr->Port(ctx->network->port, TRANSPORT_TCP)); } else { // TODO: are there any status messages where the ctx->network // is not set and actually could be? - network_info->Assign(0, zeek::make_intrusive("")); - network_info->Assign(1, zeek::val_mgr->Port(0, TRANSPORT_TCP)); + network_info->Assign(0, make_intrusive("")); + network_info->Assign(1, val_mgr->Port(0, TRANSPORT_TCP)); } endpoint_info->Assign(1, std::move(network_info)); } auto str = stat.message(); - auto msg = zeek::make_intrusive(str ? *str : ""); + auto msg = make_intrusive(str ? *str : ""); - zeek::event_mgr.Enqueue(event, std::move(endpoint_info), std::move(msg)); + event_mgr.Enqueue(event, std::move(endpoint_info), std::move(msg)); } void Manager::ProcessError(broker::error err) { - DBG_LOG(zeek::DBG_BROKER, "Received error message: %s", RenderMessage(err).c_str()); + DBG_LOG(DBG_BROKER, "Received error message: %s", RenderMessage(err).c_str()); if ( ! ::Broker::error ) return; @@ -1484,13 +1484,13 @@ void Manager::ProcessError(broker::error err) if ( err.category() == caf::atom("broker") ) { - static auto enum_type = zeek::id::find_type("Broker::ErrorCode"); + static auto enum_type = id::find_type("Broker::ErrorCode"); if ( enum_type->Lookup(err.code()) ) ec = static_cast(err.code()); else { - zeek::reporter->Warning("Unknown Broker error code %u: mapped to unspecificed enum value ", err.code()); + reporter->Warning("Unknown Broker error code %u: mapped to unspecificed enum value ", err.code()); ec = BifEnum::Broker::ErrorCode::UNSPECIFIED; } @@ -1499,24 +1499,24 @@ void Manager::ProcessError(broker::error err) else { ec = BifEnum::Broker::ErrorCode::CAF_ERROR; - msg = zeek::util::fmt("[%s] %s", caf::to_string(err.category()).c_str(), caf::to_string(err.context()).c_str()); + msg = util::fmt("[%s] %s", caf::to_string(err.category()).c_str(), caf::to_string(err.context()).c_str()); } - zeek::event_mgr.Enqueue(::Broker::error, - zeek::BifType::Enum::Broker::ErrorCode->GetEnumVal(ec), - zeek::make_intrusive(msg)); + event_mgr.Enqueue(::Broker::error, + BifType::Enum::Broker::ErrorCode->GetEnumVal(ec), + make_intrusive(msg)); } void Manager::ProcessStoreResponse(detail::StoreHandleVal* s, broker::store::response response) { - DBG_LOG(zeek::DBG_BROKER, "Received store response: %s", RenderMessage(response).c_str()); + DBG_LOG(DBG_BROKER, "Received store response: %s", RenderMessage(response).c_str()); auto request = pending_queries.find(std::make_pair(response.id, s)); if ( request == pending_queries.end() ) { - zeek::reporter->Warning("unmatched response to query %" PRIu64 " on store %s", - response.id, s->store.name().c_str()); + reporter->Warning("unmatched response to query %" PRIu64 " on store %s", + response.id, s->store.name().c_str()); return; } @@ -1545,8 +1545,8 @@ void Manager::ProcessStoreResponse(detail::StoreHandleVal* s, broker::store::res else if ( response.answer.error() == broker::ec::no_such_key ) request->second->Result(detail::query_result()); else - zeek::reporter->InternalWarning("unknown store response status: %s", - to_string(response.answer.error()).c_str()); + reporter->InternalWarning("unknown store response status: %s", + to_string(response.answer.error()).c_str()); delete request->second; pending_queries.erase(request); @@ -1561,7 +1561,7 @@ detail::StoreHandleVal* Manager::MakeMaster(const string& name, broker::backend if ( LookupStore(name) ) return nullptr; - DBG_LOG(zeek::DBG_BROKER, "Creating master for data store %s", name.c_str()); + DBG_LOG(DBG_BROKER, "Creating master for data store %s", name.c_str()); auto it = opts.find("path"); @@ -1598,7 +1598,7 @@ detail::StoreHandleVal* Manager::MakeMaster(const string& name, broker::backend Ref(handle); data_stores.emplace(name, handle); - zeek::iosource_mgr->RegisterFd(handle->proxy.mailbox().descriptor(), this); + iosource_mgr->RegisterFd(handle->proxy.mailbox().descriptor(), this); PrepareForwarding(name); if ( ! bstate->endpoint.use_real_time() ) @@ -1634,7 +1634,7 @@ void Manager::BrokerStoreToZeekTable(const std::string& name, const detail::Stor auto zeek_key = detail::data_to_val(key, its[0].get()); if ( ! zeek_key ) { - zeek::reporter->Error("Failed to convert key \"%s\" while importing broker store to table for store \"%s\". Aborting import.", to_string(key).c_str(), name.c_str()); + reporter->Error("Failed to convert key \"%s\" while importing broker store to table for store \"%s\". Aborting import.", to_string(key).c_str(), name.c_str()); // just abort - this probably means the types are incompatible table->EnableChangeNotifications(); return; @@ -1649,7 +1649,7 @@ void Manager::BrokerStoreToZeekTable(const std::string& name, const detail::Stor auto value = handle->store.get(key); if ( ! value ) { - zeek::reporter->Error("Failed to load value for key %s while importing Broker store %s to table", to_string(key).c_str(), name.c_str()); + reporter->Error("Failed to load value for key %s while importing Broker store %s to table", to_string(key).c_str(), name.c_str()); table->EnableChangeNotifications(); continue; } @@ -1657,7 +1657,7 @@ void Manager::BrokerStoreToZeekTable(const std::string& name, const detail::Stor auto zeek_value = detail::data_to_val(*value, table->GetType()->Yield().get()); if ( ! zeek_value ) { - zeek::reporter->Error("Could not convert %s to table value while trying to import Broker store %s. Aborting import.", to_string(value).c_str(), name.c_str()); + reporter->Error("Could not convert %s to table value while trying to import Broker store %s. Aborting import.", to_string(value).c_str(), name.c_str()); table->EnableChangeNotifications(); return; } @@ -1679,7 +1679,7 @@ detail::StoreHandleVal* Manager::MakeClone(const string& name, double resync_int if ( LookupStore(name) ) return nullptr; - DBG_LOG(zeek::DBG_BROKER, "Creating clone for data store %s", name.c_str()); + DBG_LOG(DBG_BROKER, "Creating clone for data store %s", name.c_str()); auto result = bstate->endpoint.attach_clone(name, resync_interval, stale_interval, @@ -1695,7 +1695,7 @@ detail::StoreHandleVal* Manager::MakeClone(const string& name, double resync_int Ref(handle); data_stores.emplace(name, handle); - zeek::iosource_mgr->RegisterFd(handle->proxy.mailbox().descriptor(), this); + iosource_mgr->RegisterFd(handle->proxy.mailbox().descriptor(), this); PrepareForwarding(name); return handle; } @@ -1708,13 +1708,13 @@ detail::StoreHandleVal* Manager::LookupStore(const string& name) bool Manager::CloseStore(const string& name) { - DBG_LOG(zeek::DBG_BROKER, "Closing data store %s", name.c_str()); + DBG_LOG(DBG_BROKER, "Closing data store %s", name.c_str()); auto s = data_stores.find(name); if ( s == data_stores.end() ) return false; - zeek::iosource_mgr->UnregisterFd(s->second->proxy.mailbox().descriptor(), this); + iosource_mgr->UnregisterFd(s->second->proxy.mailbox().descriptor(), this); for ( auto i = pending_queries.begin(); i != pending_queries.end(); ) if ( i->second->Store().name() == name ) @@ -1756,15 +1756,15 @@ const Stats& Manager::GetStatistics() return statistics; } -bool Manager::AddForwardedStore(const std::string& name, zeek::TableValPtr table) +bool Manager::AddForwardedStore(const std::string& name, TableValPtr table) { if ( forwarded_stores.find(name) != forwarded_stores.end() ) { - zeek::reporter->Error("same &broker_store %s specified for two different variables", name.c_str()); + reporter->Error("same &broker_store %s specified for two different variables", name.c_str()); return false; } - DBG_LOG(zeek::DBG_BROKER, "Adding table forward for data store %s", name.c_str()); + DBG_LOG(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(zeek::DBG_BROKER, "Resolved table forward for data store %s", name.c_str()); + DBG_LOG(DBG_BROKER, "Resolved table forward for data store %s", name.c_str()); } } // namespace zeek::Broker diff --git a/src/broker/Manager.h b/src/broker/Manager.h index 7721dde2fe..fca8c26b77 100644 --- a/src/broker/Manager.h +++ b/src/broker/Manager.h @@ -28,8 +28,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(VectorType, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(TableVal, zeek); namespace zeek { -using VectorTypePtr = zeek::IntrusivePtr; -using TableValPtr = zeek::IntrusivePtr; +using VectorTypePtr = IntrusivePtr; +using TableValPtr = IntrusivePtr; namespace Broker { @@ -68,7 +68,7 @@ struct Stats { * Manages various forms of communication between peer Bro processes * or other external applications via use of the Broker messaging library. */ -class Manager : public zeek::iosource::IOSource { +class Manager : public iosource::IOSource { public: static const broker::endpoint_info NoPeer; @@ -173,7 +173,7 @@ public: * a Broker::Event record type. * @return true if the message is sent successfully. */ - bool PublishEvent(std::string topic, zeek::RecordVal* ev); + bool PublishEvent(std::string topic, RecordVal* ev); /** * Send a message to create a log stream to any interested peers. @@ -188,10 +188,10 @@ public: * @param peer If given, send the message only to this peer. * @return true if the message is sent successfully. */ - bool PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer, - const zeek::logging::WriterBackend::WriterInfo& info, + bool PublishLogCreate(EnumVal* stream, EnumVal* writer, + const logging::WriterBackend::WriterInfo& info, int num_fields, - const zeek::threading::Field* const * fields, + const threading::Field* const * fields, const broker::endpoint_info& peer = NoPeer); /** @@ -205,9 +205,9 @@ public: * See the Broker::SendFlags record type. * @return true if the message is sent successfully. */ - bool PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, + bool PublishLogWrite(EnumVal* stream, EnumVal* writer, std::string path, int num_vals, - const zeek::threading::Value* const * vals); + const threading::Value* const * vals); /** * Automatically send an event to any interested peers whenever it is @@ -218,7 +218,7 @@ public: * @param event a Bro event value. * @return true if automatic event sending is now enabled. */ - bool AutoPublishEvent(std::string topic, zeek::Val* event); + bool AutoPublishEvent(std::string topic, Val* event); /** * Stop automatically sending an event to peers upon local dispatch. @@ -226,7 +226,7 @@ public: * @param event an event originally given to bro_broker::Manager::AutoPublish(). * @return true if automatic events will no occur for the topic/event pair. */ - bool AutoUnpublishEvent(const std::string& topic, zeek::Val* event); + bool AutoUnpublishEvent(const std::string& topic, Val* event); /** * Create an `Event` record value from an event and its arguments. @@ -236,7 +236,7 @@ public: * @return an `Event` record value. If an invalid event or arguments * were supplied the optional "name" field will not be set. */ - zeek::RecordVal* MakeEvent(ValPList* args, zeek::detail::Frame* frame); + RecordVal* MakeEvent(ValPList* args, zeek::detail::Frame* frame); /** * Register interest in peer event messages that use a certain topic prefix. @@ -315,7 +315,7 @@ public: * @param table pointer to the table/set that is being backed. * @return true on success, false if the named store is already being forwarded. */ - bool AddForwardedStore(const std::string& name, zeek::TableValPtr table); + bool AddForwardedStore(const std::string& name, TableValPtr table); /** * Close and unregister a data store. Any existing references to the @@ -365,7 +365,7 @@ private: // Process events used for Broker store backed zeek tables void ProcessStoreEvent(broker::data msg); // Common functionality for processing insert and update events. - void ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table, const std::string& store_id, const broker::data& key, const broker::data& data, const broker::data& old_value, bool insert); + void ProcessStoreEventInsertUpdate(const TableValPtr& table, const std::string& store_id, const broker::data& key, const broker::data& data, const broker::data& old_value, bool insert); void ProcessEvent(const broker::topic& topic, broker::zeek::Event ev); bool ProcessLogCreate(broker::zeek::LogCreate lc); bool ProcessLogWrite(broker::zeek::LogWrite lw); @@ -415,7 +415,7 @@ private: std::string default_log_topic_prefix; std::shared_ptr bstate; std::unordered_map data_stores; - std::unordered_map forwarded_stores; + std::unordered_map forwarded_stores; std::unordered_map pending_queries; std::vector forwarded_prefixes; @@ -428,10 +428,10 @@ private: int peer_count; size_t log_batch_size; - zeek::Func* log_topic_func; - zeek::VectorTypePtr vector_of_data_type; - zeek::EnumType* log_id_type; - zeek::EnumType* writer_id_type; + Func* log_topic_func; + VectorTypePtr vector_of_data_type; + EnumType* log_id_type; + EnumType* writer_id_type; bool zeek_table_manager = false; std::string zeek_table_db_directory; diff --git a/src/broker/Store.cc b/src/broker/Store.cc index c0f7f47dc7..1687780911 100644 --- a/src/broker/Store.cc +++ b/src/broker/Store.cc @@ -8,15 +8,15 @@ zeek::OpaqueTypePtr& bro_broker::opaque_of_store_handle = zeek::Broker::detail:: namespace zeek::Broker::detail { -zeek::EnumValPtr query_status(bool success) +EnumValPtr query_status(bool success) { - static zeek::EnumType* store_query_status = nullptr; + static EnumType* store_query_status = nullptr; static int success_val; static int failure_val; if ( ! store_query_status ) { - store_query_status = zeek::id::find_type("Broker::QueryStatus")->AsEnumType(); + store_query_status = id::find_type("Broker::QueryStatus")->AsEnumType(); success_val = store_query_status->Lookup("Broker", "SUCCESS"); failure_val = store_query_status->Lookup("Broker", "FAILURE"); } @@ -25,7 +25,7 @@ zeek::EnumValPtr query_status(bool success) return rval; } -void StoreHandleVal::ValDescribe(zeek::ODesc* d) const +void StoreHandleVal::ValDescribe(ODesc* d) const { //using BifEnum::Broker::BackendType; d->Add("broker::store::"); @@ -100,7 +100,7 @@ broker::backend to_backend_type(BifEnum::Broker::BackendType type) } broker::backend_options to_backend_options(broker::backend backend, - zeek::RecordVal* options) + RecordVal* options) { switch ( backend ) { case broker::backend::sqlite: diff --git a/src/broker/Store.h b/src/broker/Store.h index 60bbfc4ad0..833f14ae5d 100644 --- a/src/broker/Store.h +++ b/src/broker/Store.h @@ -12,24 +12,24 @@ namespace zeek::Broker::detail { -extern zeek::OpaqueTypePtr opaque_of_store_handle; +extern OpaqueTypePtr opaque_of_store_handle; /** * Create a Broker::QueryStatus value. * @param success whether the query status should be set to success or failure. * @return a Broker::QueryStatus value. */ -zeek::EnumValPtr query_status(bool success); +EnumValPtr query_status(bool success); /** * @return a Broker::QueryResult value that has a Broker::QueryStatus indicating * a failure. */ -inline zeek::RecordValPtr query_result() +inline RecordValPtr query_result() { - auto rval = zeek::make_intrusive(zeek::BifType::Record::Broker::QueryResult); + auto rval = make_intrusive(BifType::Record::Broker::QueryResult); rval->Assign(0, query_status(false)); - rval->Assign(1, zeek::make_intrusive(zeek::BifType::Record::Broker::Data)); + rval->Assign(1, make_intrusive(BifType::Record::Broker::Data)); return rval; } @@ -38,9 +38,9 @@ inline zeek::RecordValPtr query_result() * @return a Broker::QueryResult value that has a Broker::QueryStatus indicating * a success. */ -inline zeek::RecordValPtr query_result(zeek::RecordValPtr data) +inline RecordValPtr query_result(RecordValPtr data) { - auto rval = zeek::make_intrusive(zeek::BifType::Record::Broker::QueryResult); + auto rval = make_intrusive(BifType::Record::Broker::QueryResult); rval->Assign(0, query_status(true)); rval->Assign(1, std::move(data)); return rval; @@ -82,7 +82,7 @@ public: Unref(trigger); } - void Result(const zeek::RecordValPtr& result) + void Result(const RecordValPtr& result) { trigger->Cache(call, result.get()); trigger->Release(); @@ -111,27 +111,27 @@ private: /** * An opaque handle which wraps a Broker data store. */ -class StoreHandleVal : public zeek::OpaqueVal { +class StoreHandleVal : public OpaqueVal { public: StoreHandleVal(broker::store s) - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_store_handle), store{s}, proxy{store}, store_pid{store.frontend_id()} + : OpaqueVal(Broker::detail::opaque_of_store_handle), store{s}, proxy{store}, store_pid{store.frontend_id()} { } - void ValDescribe(zeek::ODesc* d) const override; + void ValDescribe(ODesc* d) const override; broker::store store; broker::store::proxy proxy; broker::publisher_id store_pid; // Zeek table that events are forwarded to. - zeek::TableValPtr forward_to; + TableValPtr forward_to; protected: - zeek::IntrusivePtr DoClone(CloneState* state) override - { return { zeek::NewRef{}, this }; } + IntrusivePtr DoClone(CloneState* state) override + { return { NewRef{}, this }; } StoreHandleVal() - : zeek::OpaqueVal(zeek::Broker::detail::opaque_of_store_handle) + : OpaqueVal(Broker::detail::opaque_of_store_handle) {} DECLARE_OPAQUE_VALUE(StoreHandleVal) @@ -142,7 +142,7 @@ broker::backend to_backend_type(BifEnum::Broker::BackendType type); // Helper function to construct broker backend options from script land. broker::backend_options to_backend_options(broker::backend backend, - zeek::RecordVal* options); + RecordVal* options); } // namespace zeek::Broker diff --git a/src/digest.cc b/src/digest.cc index 4c3919bf8c..2157795896 100644 --- a/src/digest.cc +++ b/src/digest.cc @@ -40,11 +40,11 @@ EVP_MD_CTX* hash_init(HashAlgorithm alg) md = EVP_sha512(); break; default: - zeek::reporter->InternalError("Unknown hash algorithm passed to hash_init"); + reporter->InternalError("Unknown hash algorithm passed to hash_init"); } if ( ! EVP_DigestInit_ex(c, md, NULL) ) - zeek::reporter->InternalError("EVP_DigestInit failed"); + reporter->InternalError("EVP_DigestInit failed"); return c; } @@ -52,13 +52,13 @@ EVP_MD_CTX* hash_init(HashAlgorithm alg) void hash_update(EVP_MD_CTX* c, const void* data, unsigned long len) { if ( ! EVP_DigestUpdate(c, data, len) ) - zeek::reporter->InternalError("EVP_DigestUpdate failed"); + reporter->InternalError("EVP_DigestUpdate failed"); } void hash_final(EVP_MD_CTX* c, u_char* md) { if ( ! EVP_DigestFinal(c, md, NULL) ) - zeek::reporter->InternalError("EVP_DigestFinal failed"); + reporter->InternalError("EVP_DigestFinal failed"); EVP_MD_CTX_free(c); } diff --git a/src/file_analysis/Analyzer.cc b/src/file_analysis/Analyzer.cc index b7b156003e..665377b594 100644 --- a/src/file_analysis/Analyzer.cc +++ b/src/file_analysis/Analyzer.cc @@ -10,18 +10,18 @@ ID Analyzer::id_counter = 0; Analyzer::~Analyzer() { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Destroy file analyzer %s", + DBG_LOG(DBG_FILE_ANALYSIS, "Destroy file analyzer %s", file_mgr->GetComponentName(tag).c_str()); } -void Analyzer::SetAnalyzerTag(const zeek::file_analysis::Tag& arg_tag) +void Analyzer::SetAnalyzerTag(const file_analysis::Tag& arg_tag) { assert(! tag || tag == arg_tag); tag = arg_tag; } -Analyzer::Analyzer(zeek::file_analysis::Tag arg_tag, - zeek::RecordValPtr arg_args, +Analyzer::Analyzer(file_analysis::Tag arg_tag, + RecordValPtr arg_args, File* arg_file) : tag(arg_tag), args(std::move(arg_args)), @@ -32,18 +32,18 @@ Analyzer::Analyzer(zeek::file_analysis::Tag arg_tag, id = ++id_counter; } -Analyzer::Analyzer(zeek::RecordValPtr arg_args, File* arg_file) +Analyzer::Analyzer(RecordValPtr arg_args, File* arg_file) : Analyzer({}, std::move(arg_args), arg_file) {} -Analyzer::Analyzer(zeek::file_analysis::Tag arg_tag, - zeek::RecordVal* arg_args, +Analyzer::Analyzer(file_analysis::Tag arg_tag, + RecordVal* arg_args, File* arg_file) - : Analyzer(arg_tag, {zeek::NewRef{}, arg_args}, arg_file) + : Analyzer(arg_tag, {NewRef{}, arg_args}, arg_file) {} -Analyzer::Analyzer(zeek::RecordVal* arg_args, File* arg_file) - : Analyzer({}, {zeek::NewRef{}, arg_args}, arg_file) +Analyzer::Analyzer(RecordVal* arg_args, File* arg_file) + : Analyzer({}, {NewRef{}, arg_args}, arg_file) {} } // namespace zeek::file_analysis diff --git a/src/file_analysis/Analyzer.h b/src/file_analysis/Analyzer.h index bc7d973132..e0cf074b96 100644 --- a/src/file_analysis/Analyzer.h +++ b/src/file_analysis/Analyzer.h @@ -8,7 +8,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(RecordVal, zeek); namespace zeek { -using RecordValPtr = zeek::IntrusivePtr; +using RecordValPtr = IntrusivePtr; } ZEEK_FORWARD_DECLARE_NAMESPACED(File, zeek, file_analysis); @@ -98,11 +98,11 @@ public: /** * @return the AnalyzerArgs associated with the analyzer. */ - const zeek::RecordValPtr& GetArgs() const + const RecordValPtr& GetArgs() const { return args; } [[deprecated("Remove in v4.1. Use GetArgs().")]] - zeek::RecordVal* Args() const + RecordVal* Args() const { return args.get(); } /** @@ -154,10 +154,10 @@ protected: * tunable options, if any, related to a particular analyzer type. * @param arg_file the file to which the the analyzer is being attached. */ - Analyzer(file_analysis::Tag arg_tag, zeek::RecordValPtr arg_args, File* arg_file); + Analyzer(file_analysis::Tag arg_tag, RecordValPtr arg_args, File* arg_file); [[deprecated("Remove in v4.1.. Construct using IntrusivePtr instead.")]] - Analyzer(file_analysis::Tag arg_tag, zeek::RecordVal* arg_args, File* arg_file); + Analyzer(file_analysis::Tag arg_tag, RecordVal* arg_args, File* arg_file); /** * Constructor. Only derived classes are meant to be instantiated. @@ -168,16 +168,16 @@ protected: * tunable options, if any, related to a particular analyzer type. * @param arg_file the file to which the the analyzer is being attached. */ - Analyzer(zeek::RecordValPtr arg_args, File* arg_file); + Analyzer(RecordValPtr arg_args, File* arg_file); [[deprecated("Remove in v4.1.. Construct using IntrusivePtr instead.")]] - Analyzer(zeek::RecordVal* arg_args, File* arg_file); + Analyzer(RecordVal* arg_args, File* arg_file); private: ID id; /**< Unique instance ID. */ file_analysis::Tag tag; /**< The particular type of the analyzer instance. */ - zeek::RecordValPtr args; /**< \c AnalyzerArgs val gives tunable analyzer params. */ + RecordValPtr args; /**< \c AnalyzerArgs val gives tunable analyzer params. */ File* file; /**< The file to which the analyzer is attached. */ bool got_stream_delivery; bool skip; diff --git a/src/file_analysis/AnalyzerSet.cc b/src/file_analysis/AnalyzerSet.cc index 585db7d0c4..6c52c34080 100644 --- a/src/file_analysis/AnalyzerSet.cc +++ b/src/file_analysis/AnalyzerSet.cc @@ -20,9 +20,9 @@ static void analyzer_del_func(void* v) AnalyzerSet::AnalyzerSet(File* arg_file) : file(arg_file) { - auto t = zeek::make_intrusive(); + auto t = make_intrusive(); t->Append(file_mgr->GetTagType()); - t->Append(zeek::BifType::Record::Files::AnalyzerArgs); + t->Append(BifType::Record::Files::AnalyzerArgs); analyzer_hash = new zeek::detail::CompositeHash(std::move(t)); analyzer_map.SetDeleteFunc(analyzer_del_func); } @@ -41,20 +41,20 @@ AnalyzerSet::~AnalyzerSet() } Analyzer* AnalyzerSet::Find(const file_analysis::Tag& tag, - zeek::RecordValPtr args) + RecordValPtr args) { auto key = GetKey(tag, std::move(args)); Analyzer* rval = analyzer_map.Lookup(key.get()); return rval; } -bool AnalyzerSet::Add(const file_analysis::Tag& tag, zeek::RecordValPtr args) +bool AnalyzerSet::Add(const file_analysis::Tag& tag, RecordValPtr args) { auto key = GetKey(tag, args); if ( analyzer_map.Lookup(key.get()) ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s skipped: already exists", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s skipped: already exists", file->GetID().c_str(), file_mgr->GetComponentName(tag).c_str()); @@ -72,7 +72,7 @@ bool AnalyzerSet::Add(const file_analysis::Tag& tag, zeek::RecordValPtr args) } Analyzer* AnalyzerSet::QueueAdd(const file_analysis::Tag& tag, - zeek::RecordValPtr args) + RecordValPtr args) { auto key = GetKey(tag, args); file_analysis::Analyzer* a = InstantiateAnalyzer(tag, std::move(args)); @@ -89,7 +89,7 @@ bool AnalyzerSet::AddMod::Perform(AnalyzerSet* set) { if ( set->analyzer_map.Lookup(key.get()) ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Add analyzer %s skipped: already exists", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Add analyzer %s skipped: already exists", a->GetFile()->GetID().c_str(), file_mgr->GetComponentName(a->Tag()).c_str()); @@ -108,7 +108,7 @@ void AnalyzerSet::AddMod::Abort() } bool AnalyzerSet::Remove(const file_analysis::Tag& tag, - zeek::RecordValPtr args) + RecordValPtr args) { return Remove(tag, GetKey(tag, std::move(args))); } @@ -120,12 +120,12 @@ bool AnalyzerSet::Remove(const file_analysis::Tag& tag, if ( ! a ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Skip remove analyzer %s", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Skip remove analyzer %s", file->GetID().c_str(), file_mgr->GetComponentName(tag).c_str()); return false; } - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Remove analyzer %s", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Remove analyzer %s", file->GetID().c_str(), file_mgr->GetComponentName(tag).c_str()); @@ -140,7 +140,7 @@ bool AnalyzerSet::Remove(const file_analysis::Tag& tag, } bool AnalyzerSet::QueueRemove(const file_analysis::Tag& tag, - zeek::RecordValPtr args) + RecordValPtr args) { auto key = GetKey(tag, std::move(args)); auto rval = analyzer_map.Lookup(key.get()); @@ -154,29 +154,29 @@ bool AnalyzerSet::RemoveMod::Perform(AnalyzerSet* set) } std::unique_ptr AnalyzerSet::GetKey(const file_analysis::Tag& t, - zeek::RecordValPtr args) const + RecordValPtr args) const { - auto lv = zeek::make_intrusive(zeek::TYPE_ANY); + auto lv = make_intrusive(TYPE_ANY); lv->Append(t.AsVal()); lv->Append(std::move(args)); auto key = analyzer_hash->MakeHashKey(*lv, true); if ( ! key ) - zeek::reporter->InternalError("AnalyzerArgs type mismatch"); + reporter->InternalError("AnalyzerArgs type mismatch"); return key; } file_analysis::Analyzer* AnalyzerSet::InstantiateAnalyzer(const Tag& tag, - zeek::RecordValPtr args) const + RecordValPtr args) const { auto a = file_mgr->InstantiateAnalyzer(tag, std::move(args), file); if ( ! a ) { - zeek::reporter->Error("[%s] Failed file analyzer %s instantiation", - file->GetID().c_str(), - file_mgr->GetComponentName(tag).c_str()); + reporter->Error("[%s] Failed file analyzer %s instantiation", + file->GetID().c_str(), + file_mgr->GetComponentName(tag).c_str()); return nullptr; } @@ -186,7 +186,7 @@ file_analysis::Analyzer* AnalyzerSet::InstantiateAnalyzer(const Tag& tag, void AnalyzerSet::Insert(file_analysis::Analyzer* a, std::unique_ptr key) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Add analyzer %s", + DBG_LOG(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(zeek::DBG_FILE_ANALYSIS, "[%s] Start analyzer mod queue flush", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Start analyzer mod queue flush", file->GetID().c_str()); do { @@ -207,7 +207,7 @@ void AnalyzerSet::DrainModifications() delete mod; mod_queue.pop(); } while ( ! mod_queue.empty() ); - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] End flushing analyzer mod queue.", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] End flushing analyzer mod queue.", file->GetID().c_str()); } diff --git a/src/file_analysis/AnalyzerSet.h b/src/file_analysis/AnalyzerSet.h index c18e1e0617..216210a7e8 100644 --- a/src/file_analysis/AnalyzerSet.h +++ b/src/file_analysis/AnalyzerSet.h @@ -11,7 +11,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(CompositeHash, zeek::detail); ZEEK_FORWARD_DECLARE_NAMESPACED(RecordVal, zeek); namespace zeek { -using RecordValPtr = zeek::IntrusivePtr; +using RecordValPtr = IntrusivePtr; } ZEEK_FORWARD_DECLARE_NAMESPACED(Analyzer, zeek, file_analysis); @@ -46,7 +46,7 @@ public: * @param args an \c AnalyzerArgs record. * @return pointer to an analyzer instance, or a null pointer if not found. */ - Analyzer* Find(const file_analysis::Tag& tag, zeek::RecordValPtr args); + Analyzer* Find(const file_analysis::Tag& tag, RecordValPtr args); /** * Attach an analyzer to #file immediately. @@ -54,7 +54,7 @@ public: * @param args an \c AnalyzerArgs value which specifies an analyzer. * @return true if analyzer was instantiated/attached, else false. */ - bool Add(const file_analysis::Tag& tag, zeek::RecordValPtr args); + bool Add(const file_analysis::Tag& tag, RecordValPtr args); /** * Queue the attachment of an analyzer to #file. @@ -64,7 +64,7 @@ public: * a null pointer. The caller does *not* take ownership of the memory. */ file_analysis::Analyzer* QueueAdd(const file_analysis::Tag& tag, - zeek::RecordValPtr args); + RecordValPtr args); /** * Remove an analyzer from #file immediately. @@ -72,7 +72,7 @@ public: * @param args an \c AnalyzerArgs value which specifies an analyzer. * @return false if analyzer didn't exist and so wasn't removed, else true. */ - bool Remove(const file_analysis::Tag& tag, zeek::RecordValPtr args); + bool Remove(const file_analysis::Tag& tag, RecordValPtr args); /** * Queue the removal of an analyzer from #file. @@ -80,7 +80,7 @@ public: * @param args an \c AnalyzerArgs value which specifies an analyzer. * @return true if analyzer exists at time of call, else false; */ - bool QueueRemove(const file_analysis::Tag& tag, zeek::RecordValPtr args); + bool QueueRemove(const file_analysis::Tag& tag, RecordValPtr args); /** * Perform all queued modifications to the current analyzer set. @@ -92,7 +92,7 @@ public: * @see Dictionary#InitForIteration * @return an iterator that may be used to loop over analyzers in the set. */ - zeek::IterCookie* InitForIteration() const + IterCookie* InitForIteration() const { return analyzer_map.InitForIteration(); } /** @@ -102,7 +102,7 @@ public: * @return the next analyzer in the set or a null pointer if there is no * more left (in that case the cookie is also deleted). */ - file_analysis::Analyzer* NextEntry(zeek::IterCookie* c) + file_analysis::Analyzer* NextEntry(IterCookie* c) { return analyzer_map.NextEntry(c); } protected: @@ -114,7 +114,7 @@ protected: * @return the hash key calculated from \a args */ std::unique_ptr GetKey(const file_analysis::Tag& tag, - zeek::RecordValPtr args) const; + RecordValPtr args) const; /** * Create an instance of a file analyzer. @@ -123,7 +123,7 @@ protected: * @return a new file analyzer instance. */ file_analysis::Analyzer* InstantiateAnalyzer(const file_analysis::Tag& tag, - zeek::RecordValPtr args) const; + RecordValPtr args) const; /** * Insert an analyzer instance in to the set. @@ -144,7 +144,7 @@ private: File* file; /**< File which owns the set */ zeek::detail::CompositeHash* analyzer_hash; /**< AnalyzerArgs hashes. */ - zeek::PDict analyzer_map; /**< Indexed by AnalyzerArgs. */ + PDict analyzer_map; /**< Indexed by AnalyzerArgs. */ /** * Abstract base class for analyzer set modifications. diff --git a/src/file_analysis/Component.cc b/src/file_analysis/Component.cc index 3fcb69f970..e817dd338b 100644 --- a/src/file_analysis/Component.cc +++ b/src/file_analysis/Component.cc @@ -9,16 +9,16 @@ namespace zeek::file_analysis { Component::Component(const std::string& name, factory_callback arg_factory, Tag::subtype_t subtype) - : zeek::plugin::Component(zeek::plugin::component::FILE_ANALYZER, name), - zeek::plugin::TaggedComponent(subtype) + : plugin::Component(plugin::component::FILE_ANALYZER, name), + plugin::TaggedComponent(subtype) { factory = arg_factory; factory_func = nullptr; } Component::Component(const std::string& name, factory_function arg_factory, Tag::subtype_t subtype) - : zeek::plugin::Component(zeek::plugin::component::FILE_ANALYZER, name), - zeek::plugin::TaggedComponent(subtype) + : plugin::Component(plugin::component::FILE_ANALYZER, name), + plugin::TaggedComponent(subtype) { factory = nullptr; factory_func = arg_factory; @@ -34,7 +34,7 @@ Component::~Component() { } -void Component::DoDescribe(zeek::ODesc* d) const +void Component::DoDescribe(ODesc* d) const { if ( factory || factory_func ) { diff --git a/src/file_analysis/Component.h b/src/file_analysis/Component.h index b452536d76..c562a65ff3 100644 --- a/src/file_analysis/Component.h +++ b/src/file_analysis/Component.h @@ -25,11 +25,11 @@ namespace zeek::file_analysis { * A plugin can provide a specific file analyzer by registering this * analyzer component, describing the analyzer. */ -class Component : public zeek::plugin::Component, - public zeek::plugin::TaggedComponent { +class Component : public plugin::Component, + public plugin::TaggedComponent { public: - typedef Analyzer* (*factory_callback)(zeek::RecordVal* args, File* file); - using factory_function = Analyzer* (*)(zeek::RecordValPtr args, File* file); + typedef Analyzer* (*factory_callback)(RecordVal* args, File* file); + using factory_function = Analyzer* (*)(RecordValPtr args, File* file); /** * Constructor. @@ -80,10 +80,10 @@ protected: /** * Overriden from plugin::Component. */ - void DoDescribe(zeek::ODesc* d) const override; + void DoDescribe(ODesc* d) const override; private: - friend class zeek::file_analysis::Manager; + friend class Manager; factory_callback factory; // The analyzer's factory callback (deprecated). factory_function factory_func; // The analyzer's factory callback. diff --git a/src/file_analysis/File.cc b/src/file_analysis/File.cc index 8177d746c8..d290e32208 100644 --- a/src/file_analysis/File.cc +++ b/src/file_analysis/File.cc @@ -21,22 +21,22 @@ namespace zeek::file_analysis { -static zeek::TableValPtr empty_connection_table() +static TableValPtr empty_connection_table() { - auto tbl_index = zeek::make_intrusive(zeek::id::conn_id); - tbl_index->Append(zeek::id::conn_id); - auto tbl_type = zeek::make_intrusive(std::move(tbl_index), - zeek::id::connection); - return zeek::make_intrusive(std::move(tbl_type)); + auto tbl_index = make_intrusive(id::conn_id); + tbl_index->Append(id::conn_id); + auto tbl_type = make_intrusive(std::move(tbl_index), + id::connection); + return make_intrusive(std::move(tbl_type)); } -static zeek::RecordValPtr get_conn_id_val(const zeek::Connection* conn) +static RecordValPtr get_conn_id_val(const Connection* conn) { - auto v = zeek::make_intrusive(zeek::id::conn_id); - v->Assign(0, zeek::make_intrusive(conn->OrigAddr())); - v->Assign(1, zeek::val_mgr->Port(ntohs(conn->OrigPort()), conn->ConnTransport())); - v->Assign(2, zeek::make_intrusive(conn->RespAddr())); - v->Assign(3, zeek::val_mgr->Port(ntohs(conn->RespPort()), conn->ConnTransport())); + auto v = make_intrusive(id::conn_id); + v->Assign(0, make_intrusive(conn->OrigAddr())); + v->Assign(1, val_mgr->Port(ntohs(conn->OrigPort()), conn->ConnTransport())); + v->Assign(2, make_intrusive(conn->RespAddr())); + v->Assign(3, val_mgr->Port(ntohs(conn->RespPort()), conn->ConnTransport())); return v; } @@ -62,26 +62,26 @@ void File::StaticInit() if ( id_idx != -1 ) return; - id_idx = Idx("id", zeek::id::fa_file); - parent_id_idx = Idx("parent_id", zeek::id::fa_file); - source_idx = Idx("source", zeek::id::fa_file); - is_orig_idx = Idx("is_orig", zeek::id::fa_file); - conns_idx = Idx("conns", zeek::id::fa_file); - last_active_idx = Idx("last_active", zeek::id::fa_file); - seen_bytes_idx = Idx("seen_bytes", zeek::id::fa_file); - total_bytes_idx = Idx("total_bytes", zeek::id::fa_file); - missing_bytes_idx = Idx("missing_bytes", zeek::id::fa_file); - overflow_bytes_idx = Idx("overflow_bytes", zeek::id::fa_file); - timeout_interval_idx = Idx("timeout_interval", zeek::id::fa_file); - bof_buffer_size_idx = Idx("bof_buffer_size", zeek::id::fa_file); - bof_buffer_idx = Idx("bof_buffer", zeek::id::fa_file); - meta_mime_type_idx = Idx("mime_type", zeek::id::fa_metadata); - meta_mime_types_idx = Idx("mime_types", zeek::id::fa_metadata); - meta_inferred_idx = Idx("inferred", zeek::id::fa_metadata); + id_idx = Idx("id", id::fa_file); + parent_id_idx = Idx("parent_id", id::fa_file); + source_idx = Idx("source", id::fa_file); + is_orig_idx = Idx("is_orig", id::fa_file); + conns_idx = Idx("conns", id::fa_file); + last_active_idx = Idx("last_active", id::fa_file); + seen_bytes_idx = Idx("seen_bytes", id::fa_file); + total_bytes_idx = Idx("total_bytes", id::fa_file); + missing_bytes_idx = Idx("missing_bytes", id::fa_file); + overflow_bytes_idx = Idx("overflow_bytes", id::fa_file); + timeout_interval_idx = Idx("timeout_interval", id::fa_file); + bof_buffer_size_idx = Idx("bof_buffer_size", id::fa_file); + bof_buffer_idx = Idx("bof_buffer", id::fa_file); + meta_mime_type_idx = Idx("mime_type", id::fa_metadata); + meta_mime_types_idx = Idx("mime_types", id::fa_metadata); + meta_inferred_idx = Idx("inferred", id::fa_metadata); } -File::File(const std::string& file_id, const std::string& source_name, zeek::Connection* conn, - zeek::analyzer::Tag tag, bool is_orig) +File::File(const std::string& file_id, const std::string& source_name, Connection* conn, + analyzer::Tag tag, bool is_orig) : id(file_id), val(nullptr), file_reassembler(nullptr), stream_offset(0), reassembly_max_buffer(0), did_metadata_inference(false), reassembly_enabled(false), postpone_timeout(false), done(false), @@ -89,15 +89,15 @@ File::File(const std::string& file_id, const std::string& source_name, zeek::Con { StaticInit(); - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Creating new File object", file_id.c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Creating new File object", file_id.c_str()); - val = zeek::make_intrusive(zeek::id::fa_file); - val->Assign(id_idx, zeek::make_intrusive(file_id.c_str())); + val = make_intrusive(id::fa_file); + val->Assign(id_idx, make_intrusive(file_id.c_str())); SetSource(source_name); if ( conn ) { - val->Assign(is_orig_idx, zeek::val_mgr->Bool(is_orig)); + val->Assign(is_orig_idx, val_mgr->Bool(is_orig)); UpdateConnectionFields(conn, is_orig); } @@ -106,7 +106,7 @@ File::File(const std::string& file_id, const std::string& source_name, zeek::Con File::~File() { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Destroying File object", id.c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Destroying File object", id.c_str()); delete file_reassembler; for ( auto a : done_analyzers ) @@ -115,7 +115,7 @@ File::~File() void File::UpdateLastActivityTime() { - val->Assign(last_active_idx, zeek::make_intrusive(zeek::run_state::network_time)); + val->Assign(last_active_idx, make_intrusive(run_state::network_time)); } double File::GetLastActivityTime() const @@ -123,12 +123,12 @@ double File::GetLastActivityTime() const return val->GetField(last_active_idx)->AsTime(); } -bool File::UpdateConnectionFields(zeek::Connection* conn, bool is_orig) +bool File::UpdateConnectionFields(Connection* conn, bool is_orig) { if ( ! conn ) return false; - zeek::Val* conns = val->GetField(conns_idx).get(); + Val* conns = val->GetField(conns_idx).get(); if ( ! conns ) { @@ -146,14 +146,14 @@ bool File::UpdateConnectionFields(zeek::Connection* conn, bool is_orig) return true; } -void File::RaiseFileOverNewConnection(zeek::Connection* conn, bool is_orig) +void File::RaiseFileOverNewConnection(Connection* conn, bool is_orig) { if ( conn && FileEventAvailable(file_over_new_connection) ) { FileEvent(file_over_new_connection, { val, conn->ConnVal(), - zeek::val_mgr->Bool(is_orig), + val_mgr->Bool(is_orig), }); } } @@ -170,13 +170,13 @@ double File::LookupFieldDefaultInterval(int idx) const return v->AsInterval(); } -int File::Idx(const std::string& field, const zeek::RecordType* type) +int File::Idx(const std::string& field, const RecordType* type) { int rval = type->FieldOffset(field.c_str()); if ( rval < 0 ) - zeek::reporter->InternalError("Unknown %s field: %s", type->GetName().c_str(), - field.c_str()); + reporter->InternalError("Unknown %s field: %s", type->GetName().c_str(), + field.c_str()); return rval; } @@ -190,7 +190,7 @@ std::string File::GetSource() const void File::SetSource(const std::string& source) { - val->Assign(source_idx, zeek::make_intrusive(source.c_str())); + val->Assign(source_idx, make_intrusive(source.c_str())); } double File::GetTimeoutInterval() const @@ -200,13 +200,13 @@ double File::GetTimeoutInterval() const void File::SetTimeoutInterval(double interval) { - val->Assign(timeout_interval_idx, zeek::make_intrusive(interval)); + val->Assign(timeout_interval_idx, make_intrusive(interval)); } -bool File::SetExtractionLimit(zeek::RecordVal* args, uint64_t bytes) - { return SetExtractionLimit({zeek::NewRef{}, args}, bytes); } +bool File::SetExtractionLimit(RecordVal* args, uint64_t bytes) + { return SetExtractionLimit({NewRef{}, args}, bytes); } -bool File::SetExtractionLimit(zeek::RecordValPtr args, uint64_t bytes) +bool File::SetExtractionLimit(RecordValPtr args, uint64_t bytes) { Analyzer* a = analyzers.Find(file_mgr->GetComponentTag("EXTRACT"), std::move(args)); @@ -214,7 +214,7 @@ bool File::SetExtractionLimit(zeek::RecordValPtr args, uint64_t bytes) if ( ! a ) return false; - auto* e = dynamic_cast(a); + auto* e = dynamic_cast(a); if ( ! e ) return false; @@ -226,13 +226,13 @@ bool File::SetExtractionLimit(zeek::RecordValPtr args, uint64_t bytes) void File::IncrementByteCount(uint64_t size, int field_idx) { uint64_t old = LookupFieldDefaultCount(field_idx); - val->Assign(field_idx, zeek::val_mgr->Count(old + size)); + val->Assign(field_idx, val_mgr->Count(old + size)); } void File::SetTotalBytes(uint64_t 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)); + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Total bytes %" PRIu64, id.c_str(), size); + val->Assign(total_bytes_idx, val_mgr->Count(size)); } bool File::IsComplete() const @@ -250,15 +250,15 @@ bool File::IsComplete() const void File::ScheduleInactivityTimer() const { - zeek::detail::timer_mgr->Add(new detail::FileTimer(zeek::run_state::network_time, id, GetTimeoutInterval())); + zeek::detail::timer_mgr->Add(new detail::FileTimer(run_state::network_time, id, GetTimeoutInterval())); } -bool File::AddAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args) - { return AddAnalyzer(tag, {zeek::NewRef{}, args}); } +bool File::AddAnalyzer(file_analysis::Tag tag, RecordVal* args) + { return AddAnalyzer(tag, {NewRef{}, args}); } -bool File::AddAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args) +bool File::AddAnalyzer(file_analysis::Tag tag, RecordValPtr args) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Queuing addition of %s analyzer", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Queuing addition of %s analyzer", id.c_str(), file_mgr->GetComponentName(tag).c_str()); if ( done ) @@ -267,12 +267,12 @@ bool File::AddAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args) return analyzers.QueueAdd(tag, std::move(args)) != nullptr; } -bool File::RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args) - { return RemoveAnalyzer(tag, {zeek::NewRef{}, args}); } +bool File::RemoveAnalyzer(file_analysis::Tag tag, RecordVal* args) + { return RemoveAnalyzer(tag, {NewRef{}, args}); } -bool File::RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args) +bool File::RemoveAnalyzer(file_analysis::Tag tag, RecordValPtr args) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Queuing remove of %s analyzer", + DBG_LOG(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)); @@ -306,9 +306,9 @@ bool File::SetMime(const std::string& mime_type) if ( ! FileEventAvailable(file_sniff) ) return false; - auto meta = zeek::make_intrusive(zeek::id::fa_metadata); - meta->Assign(meta_mime_type_idx, zeek::make_intrusive(mime_type)); - meta->Assign(meta_inferred_idx, zeek::val_mgr->False()); + auto meta = make_intrusive(id::fa_metadata); + meta->Assign(meta_mime_type_idx, make_intrusive(mime_type)); + meta->Assign(meta_inferred_idx, val_mgr->False()); FileEvent(file_sniff, {val, std::move(meta)}); return true; @@ -318,15 +318,15 @@ void File::InferMetadata() { did_metadata_inference = true; - zeek::Val* bof_buffer_val = val->GetField(bof_buffer_idx).get(); + Val* bof_buffer_val = val->GetField(bof_buffer_idx).get(); if ( ! bof_buffer_val ) { if ( bof_buffer.size == 0 ) return; - zeek::String* bs = concatenate(bof_buffer.chunks); - val->Assign(bof_buffer_idx, bs); + String* bs = concatenate(bof_buffer.chunks); + val->Assign(bof_buffer_idx, bs); bof_buffer_val = val->GetField(bof_buffer_idx).get(); } @@ -339,11 +339,11 @@ void File::InferMetadata() len = std::min(len, LookupFieldDefaultCount(bof_buffer_size_idx)); file_mgr->DetectMIME(data, len, &matches); - auto meta = zeek::make_intrusive(zeek::id::fa_metadata); + auto meta = make_intrusive(id::fa_metadata); if ( ! matches.empty() ) { - meta->Assign(meta_mime_type_idx, + meta->Assign(meta_mime_type_idx, *(matches.begin()->second.begin())); meta->Assign(meta_mime_types_idx, file_analysis::GenMIMEMatchesVal(matches)); @@ -359,7 +359,7 @@ bool File::BufferBOF(const u_char* data, uint64_t len) uint64_t desired_size = LookupFieldDefaultCount(bof_buffer_size_idx); - bof_buffer.chunks.push_back(new zeek::String(data, len, false)); + bof_buffer.chunks.push_back(new String(data, len, false)); bof_buffer.size += len; if ( bof_buffer.size < desired_size ) @@ -369,8 +369,8 @@ bool File::BufferBOF(const u_char* data, uint64_t len) if ( bof_buffer.size > 0 ) { - zeek::String* bs = concatenate(bof_buffer.chunks); - val->Assign(bof_buffer_idx, zeek::make_intrusive(bs)); + String* bs = concatenate(bof_buffer.chunks); + val->Assign(bof_buffer_idx, make_intrusive(bs)); } return false; @@ -386,22 +386,22 @@ void File::DeliverStream(const u_char* data, uint64_t len) LookupFieldDefaultCount(missing_bytes_idx) == 0 ) InferMetadata(); - DBG_LOG(zeek::DBG_FILE_ANALYSIS, + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] %" PRIu64 " stream bytes in at offset %" PRIu64 "; %s [%s%s]", id.c_str(), len, stream_offset, IsComplete() ? "complete" : "incomplete", - zeek::util::fmt_bytes((const char*) data, std::min((uint64_t)40, len)), + util::fmt_bytes((const char*) data, std::min((uint64_t)40, len)), len > 40 ? "..." : ""); file_analysis::Analyzer* a = nullptr; - zeek::IterCookie* c = analyzers.InitForIteration(); + IterCookie* c = analyzers.InitForIteration(); while ( (a = analyzers.NextEntry(c)) ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str()); if ( ! a->GotStreamDelivery() ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "skipping stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str()); + DBG_LOG(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 ) @@ -462,14 +462,14 @@ void File::DeliverChunk(const u_char* data, uint64_t len, uint64_t offset) { FileEvent(file_reassembly_overflow, { val, - zeek::val_mgr->Count(current_offset), - zeek::val_mgr->Count(gap_bytes) + val_mgr->Count(current_offset), + val_mgr->Count(gap_bytes) }); } } // Forward data to the reassembler. - file_reassembler->NewBlock(zeek::run_state::network_time, offset, len, data); + file_reassembler->NewBlock(run_state::network_time, offset, len, data); } else if ( stream_offset == offset ) { @@ -482,7 +482,7 @@ void File::DeliverChunk(const u_char* data, uint64_t len, uint64_t offset) // This is data that doesn't match the offset and the reassembler // needs to be enabled. file_reassembler = new FileReassembler(this, stream_offset); - file_reassembler->NewBlock(zeek::run_state::network_time, offset, len, data); + file_reassembler->NewBlock(run_state::network_time, offset, len, data); } else { @@ -490,19 +490,19 @@ void File::DeliverChunk(const u_char* data, uint64_t len, uint64_t offset) IncrementByteCount(len, overflow_bytes_idx); } - DBG_LOG(zeek::DBG_FILE_ANALYSIS, + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] %" PRIu64 " chunk bytes in at offset %" PRIu64 "; %s [%s%s]", id.c_str(), len, offset, IsComplete() ? "complete" : "incomplete", - zeek::util::fmt_bytes((const char*) data, std::min((uint64_t)40, len)), + util::fmt_bytes((const char*) data, std::min((uint64_t)40, len)), len > 40 ? "..." : ""); file_analysis::Analyzer* a = nullptr; - zeek::IterCookie* c = analyzers.InitForIteration(); + IterCookie* c = analyzers.InitForIteration(); while ( (a = analyzers.NextEntry(c)) ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "chunk delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str()); + DBG_LOG(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(zeek::DBG_FILE_ANALYSIS, "[%s] End of file", id.c_str()); + DBG_LOG(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(zeek::DBG_FILE_ANALYSIS, "[%s] File over but bof_buffer not full.", id.c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] File over but bof_buffer not full.", id.c_str()); bof_buffer.full = true; DeliverStream((const u_char*) "", 0); } @@ -562,7 +562,7 @@ void File::EndOfFile() done = true; file_analysis::Analyzer* a = nullptr; - zeek::IterCookie* c = analyzers.InitForIteration(); + IterCookie* c = analyzers.InitForIteration(); while ( (a = analyzers.NextEntry(c)) ) { @@ -577,7 +577,7 @@ void File::EndOfFile() void File::Gap(uint64_t offset, uint64_t len) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Gap of size %" PRIu64 " at offset %" PRIu64, + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Gap of size %" PRIu64 " at offset %" PRIu64, id.c_str(), len, offset); if ( file_reassembler && ! file_reassembler->IsCurrentlyFlushing() ) @@ -589,13 +589,13 @@ void File::Gap(uint64_t offset, uint64_t len) if ( ! bof_buffer.full ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] File gap before bof_buffer filled, continued without attempting to fill bof_buffer.", id.c_str()); + DBG_LOG(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); } file_analysis::Analyzer* a = nullptr; - zeek::IterCookie* c = analyzers.InitForIteration(); + IterCookie* c = analyzers.InitForIteration(); while ( (a = analyzers.NextEntry(c)) ) { @@ -604,7 +604,7 @@ void File::Gap(uint64_t offset, uint64_t len) } if ( FileEventAvailable(file_gap) ) - FileEvent(file_gap, {val, zeek::val_mgr->Count(offset), zeek::val_mgr->Count(len)}); + FileEvent(file_gap, {val, val_mgr->Count(offset), val_mgr->Count(len)}); analyzers.DrainModifications(); @@ -612,40 +612,40 @@ void File::Gap(uint64_t offset, uint64_t len) IncrementByteCount(len, missing_bytes_idx); } -bool File::FileEventAvailable(zeek::EventHandlerPtr h) +bool File::FileEventAvailable(EventHandlerPtr h) { return h && ! file_mgr->IsIgnored(id); } -void File::FileEvent(zeek::EventHandlerPtr h) +void File::FileEvent(EventHandlerPtr h) { if ( ! FileEventAvailable(h) ) return; - FileEvent(h, zeek::Args{val}); + FileEvent(h, Args{val}); } -void File::FileEvent(zeek::EventHandlerPtr h, ValPList* vl) +void File::FileEvent(EventHandlerPtr h, ValPList* vl) { - FileEvent(h, zeek::val_list_to_args(*vl)); + FileEvent(h, val_list_to_args(*vl)); delete vl; } -void File::FileEvent(zeek::EventHandlerPtr h, ValPList vl) +void File::FileEvent(EventHandlerPtr h, ValPList vl) { - FileEvent(h, zeek::val_list_to_args(vl)); + FileEvent(h, val_list_to_args(vl)); } -void File::FileEvent(zeek::EventHandlerPtr h, zeek::Args args) +void File::FileEvent(EventHandlerPtr h, Args args) { - zeek::event_mgr.Enqueue(h, std::move(args)); + event_mgr.Enqueue(h, std::move(args)); if ( h == file_new || h == file_over_new_connection || h == file_sniff || h == file_timeout || h == file_extraction_limit ) { // immediate feedback is required for these events. - zeek::event_mgr.Drain(); + event_mgr.Drain(); analyzers.DrainModifications(); } } diff --git a/src/file_analysis/File.h b/src/file_analysis/File.h index b2daf15226..67ffa6f2f6 100644 --- a/src/file_analysis/File.h +++ b/src/file_analysis/File.h @@ -18,8 +18,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(EventHandlerPtr, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(RecordVal, zeek); ZEEK_FORWARD_DECLARE_NAMESPACED(RecordType, zeek); namespace zeek { -using RecordValPtr = zeek::IntrusivePtr; -using RecordTypePtr = zeek::IntrusivePtr; +using RecordValPtr = IntrusivePtr; +using RecordTypePtr = IntrusivePtr; } ZEEK_FORWARD_DECLARE_NAMESPACED(FileReassembler, zeek, file_analysis); @@ -42,11 +42,11 @@ public: /** * @return the wrapped \c fa_file record value, #val. */ - const zeek::RecordValPtr& ToVal() const + const RecordValPtr& ToVal() const { return val; } [[deprecated("Remove in v4.1. Use ToVal().")]] - zeek::RecordVal* GetVal() const + RecordVal* GetVal() const { return val.get(); } /** @@ -78,10 +78,10 @@ public: * @param bytes new limit. * @return false if no extraction analyzer is active, else true. */ - bool SetExtractionLimit(zeek::RecordValPtr args, uint64_t bytes); + bool SetExtractionLimit(RecordValPtr args, uint64_t bytes); [[deprecated("Remove in v4.1. Pass an IntrusivePtr instead.")]] - bool SetExtractionLimit(zeek::RecordVal* args, uint64_t bytes); + bool SetExtractionLimit(RecordVal* args, uint64_t bytes); /** * @return value of the "id" field from #val record. @@ -126,10 +126,10 @@ public: * @param args an \c AnalyzerArgs value representing a file analyzer. * @return false if analyzer can't be instantiated, else true. */ - bool AddAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args); + bool AddAnalyzer(file_analysis::Tag tag, RecordValPtr args); [[deprecated("Remove in v4.1. Pass an IntrusivePtr instead.")]] - bool AddAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args); + bool AddAnalyzer(file_analysis::Tag tag, RecordVal* args); /** * Queues removal of an analyzer. @@ -137,10 +137,10 @@ public: * @param args an \c AnalyzerArgs value representing a file analyzer. * @return true if analyzer was active at time of call, else false. */ - bool RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args); + bool RemoveAnalyzer(file_analysis::Tag tag, RecordValPtr args); [[deprecated("Remove in v4.1. Pass an IntrusivePtr instead.")]] - bool RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args); + bool RemoveAnalyzer(file_analysis::Tag tag, RecordVal* args); /** * Signal that this analyzer can be deleted once it's safe to do so. @@ -178,37 +178,37 @@ public: * @param h pointer to an event handler. * @return true if event has a handler and the file isn't ignored. */ - bool FileEventAvailable(zeek::EventHandlerPtr h); + bool FileEventAvailable(EventHandlerPtr h); /** * Raises an event related to the file's life-cycle, the only parameter * to that event is the \c fa_file record.. * @param h pointer to an event handler. */ - void FileEvent(zeek::EventHandlerPtr h); + void FileEvent(EventHandlerPtr h); /** * Raises an event related to the file's life-cycle. * @param h pointer to an event handler. * @param vl list of argument values to pass to event call. */ - [[deprecated("Remove in v4.1. Use zeek::Args overload instead.")]] - void FileEvent(zeek::EventHandlerPtr h, ValPList* vl); + [[deprecated("Remove in v4.1. Use Args overload instead.")]] + void FileEvent(EventHandlerPtr h, ValPList* vl); /** * Raises an event related to the file's life-cycle. * @param h pointer to an event handler. * @param vl list of argument values to pass to event call. */ - [[deprecated("Remove in v4.1. Use zeek::Args overload instead.")]] - void FileEvent(zeek::EventHandlerPtr h, ValPList vl); + [[deprecated("Remove in v4.1. Use Args overload instead.")]] + void FileEvent(EventHandlerPtr h, ValPList vl); /** * Raises an event related to the file's life-cycle. * @param h pointer to an event handler. * @param args list of argument values to pass to event call. */ - void FileEvent(zeek::EventHandlerPtr h, zeek::Args args); + void FileEvent(EventHandlerPtr h, Args args); /** * Sets the MIME type for a file to a specific value. @@ -252,8 +252,8 @@ protected: * of the connection to the responder. False indicates the other * direction. */ - File(const std::string& file_id, const std::string& source_name, zeek::Connection* conn = nullptr, - zeek::analyzer::Tag tag = zeek::analyzer::Tag::Error, bool is_orig = false); + File(const std::string& file_id, const std::string& source_name, Connection* conn = nullptr, + analyzer::Tag tag = analyzer::Tag::Error, bool is_orig = false); /** * Updates the "conn_ids" and "conn_uids" fields in #val record with the @@ -262,12 +262,12 @@ protected: * @param is_orig true if the connection originator is sending the file. * @return true if the connection was previously unknown. */ - bool UpdateConnectionFields(zeek::Connection* conn, bool is_orig); + bool UpdateConnectionFields(Connection* conn, bool is_orig); /** * Raise the file_over_new_connection event with given arguments. */ - void RaiseFileOverNewConnection(zeek::Connection* conn, bool is_orig); + void RaiseFileOverNewConnection(Connection* conn, bool is_orig); /** * Increment a byte count field of #val record by \a size. @@ -340,8 +340,8 @@ protected: * @param type the record type for which the field will be looked up. * @return the field offset in #val record corresponding to \a field_name. */ - static int Idx(const std::string& field_name, const zeek::RecordType* type); - static int Idx(const std::string& field_name, const zeek::RecordTypePtr& type) + static int Idx(const std::string& field_name, const RecordType* type); + static int Idx(const std::string& field_name, const RecordTypePtr& type) { return Idx(field_name, type.get()); } /** @@ -351,7 +351,7 @@ protected: protected: std::string id; /**< A pretty hash that likely identifies file */ - zeek::RecordValPtr val; /**< \c fa_file from script layer. */ + RecordValPtr val; /**< \c fa_file from script layer. */ FileReassembler* file_reassembler; /**< A reassembler for the file if it's needed. */ uint64_t stream_offset; /**< The offset of the file which has been forwarded. */ uint64_t reassembly_max_buffer; /**< Maximum allowed buffer for reassembly. */ @@ -369,7 +369,7 @@ protected: bool full; uint64_t size; - zeek::String::CVec chunks; + String::CVec chunks; } bof_buffer; /**< Beginning of file buffer. */ zeek::detail::WeirdStateMap weird_state; diff --git a/src/file_analysis/FileReassembler.cc b/src/file_analysis/FileReassembler.cc index 3f6757ffe8..ee8e2eb727 100644 --- a/src/file_analysis/FileReassembler.cc +++ b/src/file_analysis/FileReassembler.cc @@ -8,7 +8,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(File, zeek, file_analysis); namespace zeek::file_analysis { FileReassembler::FileReassembler(File *f, uint64_t starting_offset) - : zeek::Reassembler(starting_offset, zeek::REASSEM_FILE), the_file(f), flushing(false) + : Reassembler(starting_offset, REASSEM_FILE), the_file(f), flushing(false) { } @@ -41,7 +41,7 @@ uint64_t FileReassembler::FlushTo(uint64_t sequence) return rval; } -void FileReassembler::BlockInserted(zeek::DataBlockMap::const_iterator it) +void FileReassembler::BlockInserted(DataBlockMap::const_iterator it) { const auto& start_block = it->second; diff --git a/src/file_analysis/FileReassembler.h b/src/file_analysis/FileReassembler.h index 7c71736ba4..218b16561b 100644 --- a/src/file_analysis/FileReassembler.h +++ b/src/file_analysis/FileReassembler.h @@ -12,7 +12,7 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(File, zeek, file_analysis); namespace zeek::file_analysis { -class FileReassembler final : public zeek::Reassembler { +class FileReassembler final : public Reassembler { public: FileReassembler(File* f, uint64_t starting_offset); @@ -51,7 +51,7 @@ public: protected: void Undelivered(uint64_t up_to_seq) override; - void BlockInserted(zeek::DataBlockMap::const_iterator it) override; + void BlockInserted(DataBlockMap::const_iterator it) override; void Overlap(const u_char* b1, const u_char* b2, uint64_t n) override; File* the_file = nullptr; diff --git a/src/file_analysis/FileTimer.cc b/src/file_analysis/FileTimer.cc index 80d72bbbc1..2681b26d37 100644 --- a/src/file_analysis/FileTimer.cc +++ b/src/file_analysis/FileTimer.cc @@ -9,7 +9,7 @@ namespace zeek::file_analysis::detail { 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(zeek::DBG_FILE_ANALYSIS, "New %f second timeout timer for %s", + DBG_LOG(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(zeek::DBG_FILE_ANALYSIS, "Checking inactivity for %s, last active at %f, " + DBG_LOG(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 ) diff --git a/src/file_analysis/Manager.cc b/src/file_analysis/Manager.cc index 4034e93539..1fb9fad192 100644 --- a/src/file_analysis/Manager.cc +++ b/src/file_analysis/Manager.cc @@ -18,8 +18,8 @@ using namespace std; namespace zeek::file_analysis { Manager::Manager() - : plugin::ComponentManager("Files", "Tag"), + : plugin::ComponentManager("Files", "Tag"), current_file_id(), magic_state(), cumulative_files(0), max_files(0) { } @@ -62,7 +62,7 @@ void Manager::Terminate() for ( const string& key : keys ) Timeout(key, true); - zeek::event_mgr.Drain(); + event_mgr.Drain(); } string Manager::HashHandle(const string& handle) const @@ -70,7 +70,7 @@ string Manager::HashHandle(const string& handle) const zeek::detail::hash128_t hash; zeek::detail::KeyedHash::StaticHash128(handle.data(), handle.size(), &hash); - return zeek::UID(zeek::detail::bits_per_uid, hash, 2).Base62("F"); + return UID(zeek::detail::bits_per_uid, hash, 2).Base62("F"); } void Manager::SetHandle(const string& handle) @@ -79,11 +79,11 @@ void Manager::SetHandle(const string& handle) return; #ifdef DEBUG - if ( debug_logger.IsEnabled(zeek::DBG_FILE_ANALYSIS) ) + if ( debug_logger.IsEnabled(DBG_FILE_ANALYSIS) ) { - zeek::String tmp{handle}; + String tmp{handle}; auto rendered = tmp.Render(); - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Set current handle to %s", rendered); + DBG_LOG(DBG_FILE_ANALYSIS, "Set current handle to %s", rendered); delete [] rendered; } #endif @@ -92,7 +92,7 @@ void Manager::SetHandle(const string& handle) } string Manager::DataIn(const u_char* data, uint64_t len, uint64_t offset, - const zeek::analyzer::Tag& tag, zeek::Connection* conn, bool is_orig, + const analyzer::Tag& tag, Connection* conn, bool is_orig, const string& precomputed_id, const string& mime_type) { string id = precomputed_id.empty() ? GetFileID(tag, conn, is_orig) : precomputed_id; @@ -121,8 +121,8 @@ string Manager::DataIn(const u_char* data, uint64_t len, uint64_t offset, return id; } -string Manager::DataIn(const u_char* data, uint64_t len, const zeek::analyzer::Tag& tag, - zeek::Connection* conn, bool is_orig, const string& precomputed_id, +string Manager::DataIn(const u_char* data, uint64_t len, const analyzer::Tag& tag, + Connection* conn, bool is_orig, const string& precomputed_id, const string& mime_type) { string id = precomputed_id.empty() ? GetFileID(tag, conn, is_orig) : precomputed_id; @@ -150,7 +150,7 @@ string Manager::DataIn(const u_char* data, uint64_t len, const zeek::analyzer::T void Manager::DataIn(const u_char* data, uint64_t len, const string& file_id, const string& source) { - File* file = GetFile(file_id, nullptr, zeek::analyzer::Tag::Error, false, false, + File* file = GetFile(file_id, nullptr, analyzer::Tag::Error, false, false, source.c_str()); if ( ! file ) @@ -162,13 +162,13 @@ void Manager::DataIn(const u_char* data, uint64_t len, const string& file_id, RemoveFile(file->GetID()); } -void Manager::EndOfFile(const zeek::analyzer::Tag& tag, zeek::Connection* conn) +void Manager::EndOfFile(const analyzer::Tag& tag, Connection* conn) { EndOfFile(tag, conn, true); EndOfFile(tag, conn, false); } -void Manager::EndOfFile(const zeek::analyzer::Tag& tag, zeek::Connection* conn, bool is_orig) +void Manager::EndOfFile(const analyzer::Tag& tag, Connection* conn, bool is_orig) { // Don't need to create a file if we're just going to remove it right away. RemoveFile(GetFileID(tag, conn, is_orig)); @@ -179,8 +179,8 @@ void Manager::EndOfFile(const string& file_id) RemoveFile(file_id); } -string Manager::Gap(uint64_t offset, uint64_t len, const zeek::analyzer::Tag& tag, - zeek::Connection* conn, bool is_orig, const string& precomputed_id) +string Manager::Gap(uint64_t offset, uint64_t len, const analyzer::Tag& tag, + Connection* conn, bool is_orig, const string& precomputed_id) { string id = precomputed_id.empty() ? GetFileID(tag, conn, is_orig) : precomputed_id; File* file = GetFile(id, conn, tag, is_orig); @@ -192,7 +192,7 @@ string Manager::Gap(uint64_t offset, uint64_t len, const zeek::analyzer::Tag& ta return id; } -string Manager::SetSize(uint64_t size, const zeek::analyzer::Tag& tag, zeek::Connection* conn, +string Manager::SetSize(uint64_t size, const analyzer::Tag& tag, Connection* conn, bool is_orig, const string& precomputed_id) { string id = precomputed_id.empty() ? GetFileID(tag, conn, is_orig) : precomputed_id; @@ -259,12 +259,12 @@ bool Manager::SetReassemblyBuffer(const string& file_id, uint64_t max) return true; } -bool Manager::SetExtractionLimit(const string& file_id, zeek::RecordVal* args, +bool Manager::SetExtractionLimit(const string& file_id, RecordVal* args, uint64_t n) const - { return SetExtractionLimit(file_id, {zeek::NewRef{}, args}, n); } + { return SetExtractionLimit(file_id, {NewRef{}, args}, n); } bool Manager::SetExtractionLimit(const string& file_id, - zeek::RecordValPtr args, uint64_t n) const + RecordValPtr args, uint64_t n) const { File* file = LookupFile(file_id); @@ -274,12 +274,12 @@ bool Manager::SetExtractionLimit(const string& file_id, return file->SetExtractionLimit(std::move(args), n); } -bool Manager::AddAnalyzer(const string& file_id, const zeek::file_analysis::Tag& tag, - zeek::RecordVal* args) const - { return AddAnalyzer(file_id, tag, {zeek::NewRef{}, args}); } +bool Manager::AddAnalyzer(const string& file_id, const file_analysis::Tag& tag, + RecordVal* args) const + { return AddAnalyzer(file_id, tag, {NewRef{}, args}); } -bool Manager::AddAnalyzer(const string& file_id, const zeek::file_analysis::Tag& tag, - zeek::RecordValPtr args) const +bool Manager::AddAnalyzer(const string& file_id, const file_analysis::Tag& tag, + RecordValPtr args) const { File* file = LookupFile(file_id); @@ -289,12 +289,12 @@ bool Manager::AddAnalyzer(const string& file_id, const zeek::file_analysis::Tag& return file->AddAnalyzer(tag, std::move(args)); } -bool Manager::RemoveAnalyzer(const string& file_id, const zeek::file_analysis::Tag& tag, - zeek::RecordVal* args) const - { return RemoveAnalyzer(file_id, tag, {zeek::NewRef{}, args}); } +bool Manager::RemoveAnalyzer(const string& file_id, const file_analysis::Tag& tag, + RecordVal* args) const + { return RemoveAnalyzer(file_id, tag, {NewRef{}, args}); } -bool Manager::RemoveAnalyzer(const string& file_id, const zeek::file_analysis::Tag& tag, - zeek::RecordValPtr args) const +bool Manager::RemoveAnalyzer(const string& file_id, const file_analysis::Tag& tag, + RecordValPtr args) const { File* file = LookupFile(file_id); @@ -304,8 +304,8 @@ bool Manager::RemoveAnalyzer(const string& file_id, const zeek::file_analysis::T return file->RemoveAnalyzer(tag, std::move(args)); } -File* Manager::GetFile(const string& file_id, zeek::Connection* conn, - const zeek::analyzer::Tag& tag, bool is_orig, bool update_conn, +File* Manager::GetFile(const string& file_id, Connection* conn, + const analyzer::Tag& tag, bool is_orig, bool update_conn, const char* source_name) { if ( file_id.empty() ) @@ -320,7 +320,7 @@ File* Manager::GetFile(const string& file_id, zeek::Connection* conn, { rval = new File(file_id, source_name ? source_name - : zeek::analyzer_mgr->GetComponentName(tag), + : analyzer_mgr->GetComponentName(tag), conn, tag, is_orig); id_map[file_id] = rval; @@ -372,14 +372,14 @@ void Manager::Timeout(const string& file_id, bool is_terminating) if ( file->postpone_timeout && ! is_terminating ) { - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Postpone file analysis timeout for %s", + DBG_LOG(DBG_FILE_ANALYSIS, "Postpone file analysis timeout for %s", file->GetID().c_str()); file->UpdateLastActivityTime(); file->ScheduleInactivityTimer(); return; } - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "File analysis timeout for %s", + DBG_LOG(DBG_FILE_ANALYSIS, "File analysis timeout for %s", file->GetID().c_str()); RemoveFile(file->GetID()); @@ -390,7 +390,7 @@ bool Manager::IgnoreFile(const string& file_id) if ( ! LookupFile(file_id) ) return false; - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Ignore FileID %s", file_id.c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "Ignore FileID %s", file_id.c_str()); ignored.insert(file_id); return true; @@ -406,7 +406,7 @@ bool Manager::RemoveFile(const string& file_id) if ( ! f ) return false; - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Remove file", file_id.c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Remove file", file_id.c_str()); f->EndOfFile(); @@ -421,7 +421,7 @@ bool Manager::IsIgnored(const string& file_id) return ignored.find(file_id) != ignored.end(); } -string Manager::GetFileID(const zeek::analyzer::Tag& tag, zeek::Connection* c, bool is_orig) +string Manager::GetFileID(const analyzer::Tag& tag, Connection* c, bool is_orig) { current_file_id.clear(); @@ -431,22 +431,22 @@ string Manager::GetFileID(const zeek::analyzer::Tag& tag, zeek::Connection* c, b if ( ! get_file_handle ) return ""; - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Raise get_file_handle() for protocol analyzer %s", - zeek::analyzer_mgr->GetComponentName(tag).c_str()); + DBG_LOG(DBG_FILE_ANALYSIS, "Raise get_file_handle() for protocol analyzer %s", + analyzer_mgr->GetComponentName(tag).c_str()); const auto& tagval = tag.AsVal(); - zeek::event_mgr.Enqueue(get_file_handle, tagval, c->ConnVal(), zeek::val_mgr->Bool(is_orig)); - zeek::event_mgr.Drain(); // need file handle immediately so we don't have to buffer data + event_mgr.Enqueue(get_file_handle, tagval, c->ConnVal(), val_mgr->Bool(is_orig)); + event_mgr.Drain(); // need file handle immediately so we don't have to buffer data return current_file_id; } -bool Manager::IsDisabled(const zeek::analyzer::Tag& tag) +bool Manager::IsDisabled(const analyzer::Tag& tag) { if ( ! disabled ) - disabled = zeek::id::find_const("Files::disable")->AsTableVal(); + disabled = id::find_const("Files::disable")->AsTableVal(); - auto index = zeek::val_mgr->Count(bool(tag)); + auto index = val_mgr->Count(bool(tag)); auto yield = disabled->FindOrDefault(index); if ( ! yield ) @@ -455,24 +455,24 @@ bool Manager::IsDisabled(const zeek::analyzer::Tag& tag) return yield->AsBool(); } -Analyzer* Manager::InstantiateAnalyzer(const Tag& tag, zeek::RecordVal* args, File* f) const - { return InstantiateAnalyzer(tag, {zeek::NewRef{}, args}, f); } +Analyzer* Manager::InstantiateAnalyzer(const Tag& tag, RecordVal* args, File* f) const + { return InstantiateAnalyzer(tag, {NewRef{}, args}, f); } Analyzer* Manager::InstantiateAnalyzer(const Tag& tag, - zeek::RecordValPtr args, + RecordValPtr args, File* f) const { Component* c = Lookup(tag); if ( ! c ) { - zeek::reporter->InternalWarning( + reporter->InternalWarning( "unknown file analyzer instantiation request: %s", tag.AsString().c_str()); return nullptr; } - DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s", + DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s", f->id.c_str(), GetComponentName(tag).c_str()); Analyzer* a; @@ -483,13 +483,13 @@ Analyzer* Manager::InstantiateAnalyzer(const Tag& tag, a = c->factory(args.get(), f); else { - zeek::reporter->InternalWarning("file analyzer %s cannot be instantiated " - "dynamically", c->CanonicalName().c_str()); + reporter->InternalWarning("file analyzer %s cannot be instantiated " + "dynamically", c->CanonicalName().c_str()); return nullptr; } if ( ! a ) - zeek::reporter->InternalError("file analyzer instantiation failed"); + reporter->InternalError("file analyzer instantiation failed"); a->SetAnalyzerTag(tag); @@ -501,7 +501,7 @@ zeek::detail::RuleMatcher::MIME_Matches* Manager::DetectMIME( zeek::detail::RuleMatcher::MIME_Matches* rval) const { if ( ! magic_state ) - zeek::reporter->InternalError("file magic signature state not initialized"); + reporter->InternalError("file magic signature state not initialized"); rval = zeek::detail::rule_matcher->Match(magic_state, data, len, rval); zeek::detail::rule_matcher->ClearFileMagicState(magic_state); @@ -519,22 +519,22 @@ string Manager::DetectMIME(const u_char* data, uint64_t len) const return *(matches.begin()->second.begin()); } -zeek::VectorValPtr GenMIMEMatchesVal(const zeek::detail::RuleMatcher::MIME_Matches& m) +VectorValPtr GenMIMEMatchesVal(const zeek::detail::RuleMatcher::MIME_Matches& m) { - static auto mime_matches = zeek::id::find_type("mime_matches"); - static auto mime_match = zeek::id::find_type("mime_match"); - auto rval = zeek::make_intrusive(mime_matches); + static auto mime_matches = id::find_type("mime_matches"); + static auto mime_match = id::find_type("mime_match"); + auto rval = make_intrusive(mime_matches); for ( zeek::detail::RuleMatcher::MIME_Matches::const_iterator it = m.begin(); it != m.end(); ++it ) { - auto element = zeek::make_intrusive(mime_match); + auto element = make_intrusive(mime_match); for ( set::const_iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ) { - element->Assign(0, zeek::val_mgr->Int(it->first)); - element->Assign(1, zeek::make_intrusive(*it2)); + element->Assign(0, val_mgr->Int(it->first)); + element->Assign(1, make_intrusive(*it2)); } rval->Assign(rval->Size(), std::move(element)); diff --git a/src/file_analysis/Manager.h b/src/file_analysis/Manager.h index 24ddbb6ea9..0dcc23b21f 100644 --- a/src/file_analysis/Manager.h +++ b/src/file_analysis/Manager.h @@ -27,7 +27,7 @@ namespace file_analysis { /** * Main entry point for interacting with file analysis. */ -class Manager : public zeek::plugin::ComponentManager { +class Manager : public plugin::ComponentManager { public: /** @@ -104,7 +104,7 @@ public: * indicates the associate file is not going to be analyzed further. */ std::string DataIn(const u_char* data, uint64_t len, uint64_t offset, - const zeek::analyzer::Tag& tag, zeek::Connection* conn, bool is_orig, + const analyzer::Tag& tag, Connection* conn, bool is_orig, const std::string& precomputed_file_id = "", const std::string& mime_type = ""); @@ -130,8 +130,8 @@ public: * the \c get_file_handle script-layer event). An empty string * indicates the associated file is not going to be analyzed further. */ - std::string DataIn(const u_char* data, uint64_t len, const zeek::analyzer::Tag& tag, - zeek::Connection* conn, bool is_orig, + std::string DataIn(const u_char* data, uint64_t len, const analyzer::Tag& tag, + Connection* conn, bool is_orig, const std::string& precomputed_file_id = "", const std::string& mime_type = ""); @@ -153,7 +153,7 @@ public: * @param tag network protocol over which the file data is transferred. * @param conn network connection over which the file data is transferred. */ - void EndOfFile(const zeek::analyzer::Tag& tag, zeek::Connection* conn); + void EndOfFile(const analyzer::Tag& tag, Connection* conn); /** * Signal the end of file data being transferred over a connection in @@ -161,7 +161,7 @@ public: * @param tag network protocol over which the file data is transferred. * @param conn network connection over which the file data is transferred. */ - void EndOfFile(const zeek::analyzer::Tag& tag, zeek::Connection* conn, bool is_orig); + void EndOfFile(const analyzer::Tag& tag, Connection* conn, bool is_orig); /** * Signal the end of file data being transferred using the file identifier. @@ -185,8 +185,8 @@ public: * the \c get_file_handle script-layer event). An empty string * indicates the associate file is not going to be analyzed further. */ - std::string Gap(uint64_t offset, uint64_t len, const zeek::analyzer::Tag& tag, - zeek::Connection* conn, bool is_orig, + std::string Gap(uint64_t offset, uint64_t len, const analyzer::Tag& tag, + Connection* conn, bool is_orig, const std::string& precomputed_file_id = ""); /** @@ -204,7 +204,7 @@ public: * the \c get_file_handle script-layer event). An empty string * indicates the associate file is not going to be analyzed further. */ - std::string SetSize(uint64_t size, const zeek::analyzer::Tag& tag, zeek::Connection* conn, + std::string SetSize(uint64_t size, const analyzer::Tag& tag, Connection* conn, bool is_orig, const std::string& precomputed_file_id = ""); /** @@ -251,10 +251,10 @@ public: * else true. */ bool SetExtractionLimit(const std::string& file_id, - zeek::RecordValPtr args, uint64_t n) const; + RecordValPtr args, uint64_t n) const; [[deprecated("Remove in v4.1. Pass IntrusivePtr args param instead.")]] - bool SetExtractionLimit(const std::string& file_id, zeek::RecordVal* args, + bool SetExtractionLimit(const std::string& file_id, RecordVal* args, uint64_t n) const; /** @@ -275,11 +275,11 @@ public: * @return false if the analyzer failed to be instantiated, else true. */ bool AddAnalyzer(const std::string& file_id, const file_analysis::Tag& tag, - zeek::RecordValPtr args) const; + RecordValPtr args) const; [[deprecated("Remove in v4.1. Pass IntrusivePtr args param instead.")]] bool AddAnalyzer(const std::string& file_id, const file_analysis::Tag& tag, - zeek::RecordVal* args) const; + RecordVal* args) const; /** * Queue removal of an analyzer for a given file identifier. @@ -289,11 +289,11 @@ public: * @return true if the analyzer is active at the time of call, else false. */ bool RemoveAnalyzer(const std::string& file_id, const file_analysis::Tag& tag, - zeek::RecordValPtr args) const; + RecordValPtr args) const; [[deprecated("Remove in v4.1. Pass IntrusivePtr args param instead.")]] bool RemoveAnalyzer(const std::string& file_id, const file_analysis::Tag& tag, - zeek::RecordVal* args) const; + RecordVal* args) const; /** * Tells whether analysis for a file is active or ignored. @@ -309,11 +309,11 @@ public: * @param f The file analzer is to be associated with. * @return The new analyzer instance or null if tag is invalid. */ - Analyzer* InstantiateAnalyzer(const Tag& tag, zeek::RecordValPtr args, + Analyzer* InstantiateAnalyzer(const Tag& tag, RecordValPtr args, File* f) const; [[deprecated("Remove in v4.1. Pass in IntrusivePtr args instead.")]] - Analyzer* InstantiateAnalyzer(const Tag& tag, zeek::RecordVal* args, File* f) const; + Analyzer* InstantiateAnalyzer(const Tag& tag, RecordVal* args, File* f) const; /** * Returns a set of all matching MIME magic signatures for a given @@ -349,7 +349,7 @@ public: { return cumulative_files; } protected: - friend class zeek::file_analysis::detail::FileTimer; + friend class detail::FileTimer; /** * Create a new file to be analyzed or retrieve an existing one. @@ -369,8 +369,8 @@ protected: * exist, the activity time is refreshed along with any * connection-related fields. */ - File* GetFile(const std::string& file_id, zeek::Connection* conn = nullptr, - const zeek::analyzer::Tag& tag = zeek::analyzer::Tag::Error, + File* GetFile(const std::string& file_id, Connection* conn = nullptr, + const analyzer::Tag& tag = analyzer::Tag::Error, bool is_orig = false, bool update_conn = true, const char* source_name = nullptr); @@ -381,7 +381,7 @@ protected: * @param is_termination whether the Manager (and probably Bro) is in a * terminating state. If true, then the timeout cannot be postponed. */ - void Timeout(const std::string& file_id, bool is_terminating = zeek::run_state::terminating); + void Timeout(const std::string& file_id, bool is_terminating = run_state::terminating); /** * Immediately remove file_analysis::File object associated with \a file_id. @@ -401,7 +401,7 @@ protected: * @return #current_file_id, which is a hash of a unique file handle string * set by a \c get_file_handle event handler. */ - std::string GetFileID(const zeek::analyzer::Tag& tag, zeek::Connection* c, bool is_orig); + std::string GetFileID(const analyzer::Tag& tag, Connection* c, bool is_orig); /** * Check if analysis is available for files transferred over a given @@ -411,7 +411,7 @@ protected: * @return whether file analysis is disabled for the analyzer given by * \a tag. */ - static bool IsDisabled(const zeek::analyzer::Tag& tag); + static bool IsDisabled(const analyzer::Tag& tag); private: typedef std::set TagSet; @@ -425,8 +425,8 @@ private: zeek::detail::RuleFileMagicState* magic_state; /**< File magic signature match state. */ MIMEMap mime_types;/**< Mapping of MIME types to analyzers. */ - inline static zeek::TableVal* disabled = nullptr; /**< Table of disabled analyzers. */ - inline static zeek::TableType* tag_set_type = nullptr; /**< Type for set[tag]. */ + inline static TableVal* disabled = nullptr; /**< Table of disabled analyzers. */ + inline static TableType* tag_set_type = nullptr; /**< Type for set[tag]. */ size_t cumulative_files; size_t max_files; @@ -436,7 +436,7 @@ private: * Returns a script-layer value corresponding to the \c mime_matches type. * @param m The MIME match information with which to populate the value. */ -zeek::VectorValPtr GenMIMEMatchesVal(const zeek::detail::RuleMatcher::MIME_Matches& m); +VectorValPtr GenMIMEMatchesVal(const zeek::detail::RuleMatcher::MIME_Matches& m); } // namespace file_analysis diff --git a/src/file_analysis/Tag.cc b/src/file_analysis/Tag.cc index ef933f9b1f..dab314400f 100644 --- a/src/file_analysis/Tag.cc +++ b/src/file_analysis/Tag.cc @@ -18,22 +18,22 @@ Tag& Tag::operator=(const Tag& other) return *this; } -const zeek::EnumValPtr& Tag::AsVal() const +const EnumValPtr& Tag::AsVal() const { return zeek::Tag::AsVal(file_mgr->GetTagType()); } -zeek::EnumVal* Tag::AsEnumVal() const +EnumVal* Tag::AsEnumVal() const { return AsVal().get(); } -Tag::Tag(zeek::EnumValPtr val) +Tag::Tag(EnumValPtr val) : zeek::Tag(std::move(val)) { } -Tag::Tag(zeek::EnumVal* val) - : zeek::Tag({zeek::NewRef{}, val}) +Tag::Tag(EnumVal* val) + : zeek::Tag({NewRef{}, val}) { } } // namespace zeek::file_analysis diff --git a/src/file_analysis/Tag.h b/src/file_analysis/Tag.h index 2ca3233a5f..75e9f42df2 100644 --- a/src/file_analysis/Tag.h +++ b/src/file_analysis/Tag.h @@ -88,16 +88,16 @@ public: * * @param etype the script-layer enum type associated with the tag. */ - const zeek::EnumValPtr& AsVal() const; + const EnumValPtr& AsVal() const; [[deprecated("Remove in v4.1. Use AsVal() instead.")]] - zeek::EnumVal* AsEnumVal() const; + EnumVal* AsEnumVal() const; static const Tag Error; protected: - friend class zeek::plugin::ComponentManager; - friend class zeek::plugin::TaggedComponent; + friend class plugin::ComponentManager; + friend class plugin::TaggedComponent; /** * Constructor. @@ -116,10 +116,10 @@ protected: * * @param val An enum value of script type \c Files::Tag. */ - explicit Tag(zeek::EnumValPtr val); + explicit Tag(EnumValPtr val); [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit Tag(zeek::EnumVal* val); + explicit Tag(EnumVal* val); }; } // namespace zeek::file_analysis diff --git a/src/fuzzers/FuzzBuffer.cc b/src/fuzzers/FuzzBuffer.cc index def5d34086..5a2ae4573c 100644 --- a/src/fuzzers/FuzzBuffer.cc +++ b/src/fuzzers/FuzzBuffer.cc @@ -6,7 +6,9 @@ #include "FuzzBuffer.h" -bool zeek::detail::FuzzBuffer::Valid(int chunk_count_limit) const +namespace zeek::detail { + +bool FuzzBuffer::Valid(int chunk_count_limit) const { if ( end - begin < PKT_MAGIC_LEN + 2 ) return false; @@ -20,7 +22,7 @@ bool zeek::detail::FuzzBuffer::Valid(int chunk_count_limit) const return true; } -int zeek::detail::FuzzBuffer::ChunkCount(int chunk_count_limit) const +int FuzzBuffer::ChunkCount(int chunk_count_limit) const { auto pos = begin; int chunks = 0; @@ -39,7 +41,7 @@ int zeek::detail::FuzzBuffer::ChunkCount(int chunk_count_limit) const return chunks; } -std::optional zeek::detail::FuzzBuffer::Next() +std::optional FuzzBuffer::Next() { if ( begin == end ) return {}; @@ -86,3 +88,5 @@ std::optional zeek::detail::FuzzBuffer::Next() return {}; } + +} // namespace zeek::detail diff --git a/src/fuzzers/FuzzBuffer.h b/src/fuzzers/FuzzBuffer.h index 69ba821242..87ebebaa14 100644 --- a/src/fuzzers/FuzzBuffer.h +++ b/src/fuzzers/FuzzBuffer.h @@ -4,7 +4,7 @@ #include #include -namespace zeek { namespace detail { +namespace zeek::detail { /** * This structure helps chunk/simulate protocol conversions from arbitrary @@ -71,4 +71,4 @@ private: const unsigned char* end; }; -}} // namespace zeek::detail +} // namespace zeek::detail diff --git a/src/fuzzers/fuzzer-setup.h b/src/fuzzers/fuzzer-setup.h index 42f5cd9959..e2e30da063 100644 --- a/src/fuzzers/fuzzer-setup.h +++ b/src/fuzzers/fuzzer-setup.h @@ -45,7 +45,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv) return 0; } -namespace zeek { namespace detail { +namespace zeek::detail { void fuzzer_cleanup_one_input() { @@ -61,4 +61,4 @@ void fuzzer_cleanup_one_input() run_state::terminating = false; } -}} // namespace zeek::detail +} // namespace zeek::detail diff --git a/src/input.h b/src/input.h index a50ae842ae..616800e2f6 100644 --- a/src/input.h +++ b/src/input.h @@ -46,7 +46,7 @@ extern std::vector zeek_script_prefixes; // -p flag extern const char* command_line_policy; // -e flag extern std::vector params; -extern zeek::detail::Stmt* stmts; // global statements +extern Stmt* stmts; // global statements } // namespace zeek::detail diff --git a/src/input/Component.cc b/src/input/Component.cc index 07e1a0f5a5..6ec6eb4c79 100644 --- a/src/input/Component.cc +++ b/src/input/Component.cc @@ -9,7 +9,7 @@ namespace zeek::input { Component::Component(const std::string& name, factory_callback arg_factory) - : zeek::plugin::Component(zeek::plugin::component::READER, name) + : plugin::Component(plugin::component::READER, name) { factory = arg_factory; } @@ -24,7 +24,7 @@ Component::~Component() { } -void Component::DoDescribe(zeek::ODesc* d) const +void Component::DoDescribe(ODesc* d) const { d->Add("Input::READER_"); d->Add(CanonicalName()); diff --git a/src/input/Component.h b/src/input/Component.h index ec328206f1..189a3eaef2 100644 --- a/src/input/Component.h +++ b/src/input/Component.h @@ -14,8 +14,8 @@ namespace zeek::input { /** * Component description for plugins providing log readers. */ -class Component : public zeek::plugin::Component, - public plugin::TaggedComponent { +class Component : public plugin::Component, + public plugin::TaggedComponent { public: typedef ReaderBackend* (*factory_callback)(ReaderFrontend* frontend); @@ -54,7 +54,7 @@ protected: /** * Overriden from plugin::Component. */ - void DoDescribe(zeek::ODesc* d) const override; + void DoDescribe(ODesc* d) const override; private: factory_callback factory; diff --git a/src/input/Manager.cc b/src/input/Manager.cc index 5dd1767b57..d9347ada17 100644 --- a/src/input/Manager.cc +++ b/src/input/Manager.cc @@ -62,12 +62,12 @@ public: StreamType stream_type; // to distinguish between event and table streams - zeek::EnumVal* type; + EnumVal* type; ReaderFrontend* reader; - zeek::TableVal* config; - zeek::EventHandlerPtr error_event; + TableVal* config; + EventHandlerPtr error_event; - zeek::RecordVal* description; + RecordVal* description; virtual ~Stream(); @@ -96,16 +96,16 @@ public: unsigned int num_val_fields; bool want_record; - zeek::TableVal* tab; - zeek::RecordType* rtype; - zeek::RecordType* itype; + TableVal* tab; + RecordType* rtype; + RecordType* itype; - zeek::PDict* currDict; - zeek::PDict* lastDict; + PDict* currDict; + PDict* lastDict; - zeek::Func* pred; + Func* pred; - zeek::EventHandlerPtr event; + EventHandlerPtr event; TableStream(); ~TableStream() override; @@ -113,9 +113,9 @@ public: class Manager::EventStream final : public Manager::Stream { public: - zeek::EventHandlerPtr event; + EventHandlerPtr event; - zeek::RecordType* fields; + RecordType* fields; unsigned int num_fields; bool want_record; @@ -186,7 +186,7 @@ Manager::AnalysisStream::~AnalysisStream() Manager::Manager() : plugin::ComponentManager("Input", "Reader") { - end_of_data = zeek::event_registry->Register("Input::end_of_data"); + end_of_data = event_registry->Register("Input::end_of_data"); } Manager::~Manager() @@ -199,13 +199,13 @@ Manager::~Manager() } -ReaderBackend* Manager::CreateBackend(ReaderFrontend* frontend, zeek::EnumVal* tag) +ReaderBackend* Manager::CreateBackend(ReaderFrontend* frontend, EnumVal* tag) { Component* c = Lookup(tag); if ( ! c ) { - zeek::reporter->Error("The reader that was requested was not found and could not be initialized."); + reporter->Error("The reader that was requested was not found and could not be initialized."); return nullptr; } @@ -216,14 +216,14 @@ ReaderBackend* Manager::CreateBackend(ReaderFrontend* frontend, zeek::EnumVal* t } // Create a new input reader object to be used at whomevers leisure later on. -bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) +bool Manager::CreateStream(Stream* info, RecordVal* description) { - zeek::RecordType* rtype = description->GetType()->AsRecordType(); - if ( ! ( same_type(rtype, zeek::BifType::Record::Input::TableDescription, false) - || same_type(rtype, zeek::BifType::Record::Input::EventDescription, false) - || same_type(rtype, zeek::BifType::Record::Input::AnalysisDescription, false) ) ) + RecordType* rtype = description->GetType()->AsRecordType(); + if ( ! ( same_type(rtype, BifType::Record::Input::TableDescription, false) + || same_type(rtype, BifType::Record::Input::EventDescription, false) + || same_type(rtype, BifType::Record::Input::AnalysisDescription, false) ) ) { - zeek::reporter->Error("Stream description argument not of right type for new input stream"); + reporter->Error("Stream description argument not of right type for new input stream"); return false; } @@ -231,8 +231,8 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) if ( Stream *i = FindStream(name) ) { - zeek::reporter->Error("Trying create already existing input stream %s", - name.c_str()); + reporter->Error("Trying create already existing input stream %s", + name.c_str()); return false; } @@ -240,12 +240,12 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) // get the source ... auto source_val = description->GetFieldOrDefault("source"); - const zeek::String* bsource = source_val->AsString(); + const String* bsource = source_val->AsString(); string source((const char*) bsource->Bytes(), bsource->Len()); ReaderBackend::ReaderInfo rinfo; - rinfo.source = zeek::util::copy_string(source.c_str()); - rinfo.name = zeek::util::copy_string(name.c_str()); + rinfo.source = util::copy_string(source.c_str()); + rinfo.name = util::copy_string(name.c_str()); auto mode_val = description->GetFieldOrDefault("mode"); auto mode = mode_val->AsEnumVal(); @@ -264,7 +264,7 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) break; default: - zeek::reporter->InternalWarning("unknown input reader mode"); + reporter->InternalWarning("unknown input reader mode"); return false; } @@ -274,15 +274,15 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) { // create config mapping in ReaderInfo. Has to be done before the construction of reader_obj. zeek::detail::HashKey* k; - zeek::IterCookie* c = info->config->AsTable()->InitForIteration(); + IterCookie* c = info->config->AsTable()->InitForIteration(); - zeek::TableEntryVal* v; + TableEntryVal* v; while ( (v = info->config->AsTable()->NextEntry(k, c)) ) { auto index = info->config->RecreateIndex(*k); string key = index->Idx(0)->AsString()->CheckString(); string value = v->GetVal()->AsString()->CheckString(); - rinfo.config.insert(std::make_pair(zeek::util::copy_string(key.c_str()), zeek::util::copy_string(value.c_str()))); + rinfo.config.insert(std::make_pair(util::copy_string(key.c_str()), util::copy_string(value.c_str()))); delete k; } } @@ -298,38 +298,38 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description) info->description = description; - DBG_LOG(zeek::DBG_INPUT, "Successfully created new input stream %s", + DBG_LOG(DBG_INPUT, "Successfully created new input stream %s", name.c_str()); return true; } -bool Manager::CreateEventStream(zeek::RecordVal* fval) +bool Manager::CreateEventStream(RecordVal* fval) { - zeek::RecordType* rtype = fval->GetType()->AsRecordType(); - if ( ! same_type(rtype, zeek::BifType::Record::Input::EventDescription, false) ) + RecordType* rtype = fval->GetType()->AsRecordType(); + if ( ! same_type(rtype, BifType::Record::Input::EventDescription, false) ) { - zeek::reporter->Error("EventDescription argument not of right type"); + reporter->Error("EventDescription argument not of right type"); return false; } string stream_name = fval->GetFieldOrDefault("name")->AsString()->CheckString(); auto fields_val = fval->GetFieldOrDefault("fields"); - zeek::RecordType* fields = fields_val->AsType()->AsTypeType()->GetType()->AsRecordType(); + RecordType* fields = fields_val->AsType()->AsTypeType()->GetType()->AsRecordType(); auto want_record = fval->GetFieldOrDefault("want_record"); auto ev_val = fval->GetFieldOrDefault("ev"); - zeek::Func* event = ev_val->AsFunc(); + Func* event = ev_val->AsFunc(); const auto& etype = event->GetType(); bool allow_file_func = false; - if ( etype->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( etype->Flavor() != FUNC_FLAVOR_EVENT ) { - zeek::reporter->Error("Input stream %s: Stream event is a function, not an event", stream_name.c_str()); + reporter->Error("Input stream %s: Stream event is a function, not an event", stream_name.c_str()); return false; } @@ -337,19 +337,19 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) if ( args.size() < 2 ) { - zeek::reporter->Error("Input stream %s: Event does not take enough arguments", stream_name.c_str()); + reporter->Error("Input stream %s: Event does not take enough arguments", stream_name.c_str()); return false; } - if ( ! same_type(args[1], zeek::BifType::Enum::Input::Event, false) ) + if ( ! same_type(args[1], BifType::Enum::Input::Event, false) ) { - zeek::reporter->Error("Input stream %s: Event's second attribute must be of type Input::Event", stream_name.c_str()); + reporter->Error("Input stream %s: Event's second attribute must be of type Input::Event", stream_name.c_str()); return false; } - if ( ! same_type(args[0], zeek::BifType::Record::Input::EventDescription, false) ) + if ( ! same_type(args[0], BifType::Record::Input::EventDescription, false) ) { - zeek::reporter->Error("Input stream %s: Event's first attribute must be of type Input::EventDescription", stream_name.c_str()); + reporter->Error("Input stream %s: Event's first attribute must be of type Input::EventDescription", stream_name.c_str()); return false; } @@ -357,7 +357,7 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) { if ( static_cast(args.size()) != fields->NumFields() + 2 ) { - zeek::reporter->Error("Input stream %s: Event has wrong number of arguments", stream_name.c_str()); + reporter->Error("Input stream %s: Event has wrong number of arguments", stream_name.c_str()); return false; } @@ -365,15 +365,15 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) { if ( ! same_type(args[i + 2], fields->GetFieldType(i) ) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; args[i + 2]->Describe(&desc1); fields->GetFieldType(i)->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Incompatible type for event in field %d. Need type '%s':%s, got '%s':%s", - stream_name.c_str(), i + 3, - zeek::type_name(fields->GetFieldType(i)->Tag()), desc2.Description(), - zeek::type_name(args[i + 2]->Tag()), desc1.Description()); + reporter->Error("Input stream %s: Incompatible type for event in field %d. Need type '%s':%s, got '%s':%s", + stream_name.c_str(), i + 3, + type_name(fields->GetFieldType(i)->Tag()), desc2.Description(), + type_name(args[i + 2]->Tag()), desc1.Description()); return false; } @@ -385,24 +385,24 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) { if ( args.size() != 3 ) { - zeek::reporter->Error("Input stream %s: Event has wrong number of arguments", stream_name.c_str()); + reporter->Error("Input stream %s: Event has wrong number of arguments", stream_name.c_str()); return false; } if ( ! same_type(args[2], fields ) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; args[2]->Describe(&desc1); fields->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Incompatible type '%s':%s for event, which needs type '%s':%s\n", - stream_name.c_str(), - zeek::type_name(args[2]->Tag()), desc1.Description(), - zeek::type_name(fields->Tag()), desc2.Description()); + reporter->Error("Input stream %s: Incompatible type '%s':%s for event, which needs type '%s':%s\n", + stream_name.c_str(), + type_name(args[2]->Tag()), desc1.Description(), + type_name(fields->Tag()), desc2.Description()); return false; } - allow_file_func = zeek::BifConst::Input::accept_unsupported_types; + allow_file_func = BifConst::Input::accept_unsupported_types; } @@ -410,7 +410,7 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) assert(false); auto error_event_val = fval->GetFieldOrDefault("error_ev"); - zeek::Func* error_event = error_event_val ? error_event_val->AsFunc() : nullptr; + Func* error_event = error_event_val ? error_event_val->AsFunc() : nullptr; if ( ! CheckErrorEventTypes(stream_name, error_event, false) ) return false; @@ -421,7 +421,7 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) if ( status ) { - zeek::reporter->Error("Input stream %s: Problem unrolling", stream_name.c_str()); + reporter->Error("Input stream %s: Problem unrolling", stream_name.c_str()); for ( auto& f : fieldsV ) delete f; return false; } @@ -442,8 +442,8 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) stream->num_fields = fieldsV.size(); stream->fields = fields->Ref()->AsRecordType(); - stream->event = zeek::event_registry->Lookup(event->Name()); - stream->error_event = error_event ? zeek::event_registry->Lookup(error_event->Name()) : nullptr; + stream->event = event_registry->Lookup(event->Name()); + stream->error_event = error_event ? event_registry->Lookup(error_event->Name()) : nullptr; stream->want_record = ( want_record->InternalInt() == 1 ); assert(stream->reader); @@ -452,18 +452,18 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval) readers[stream->reader] = stream; - DBG_LOG(zeek::DBG_INPUT, "Successfully created event stream %s", + DBG_LOG(DBG_INPUT, "Successfully created event stream %s", stream->name.c_str()); return true; } -bool Manager::CreateTableStream(zeek::RecordVal* fval) +bool Manager::CreateTableStream(RecordVal* fval) { - zeek::RecordType* rtype = fval->GetType()->AsRecordType(); - if ( ! same_type(rtype, zeek::BifType::Record::Input::TableDescription, false) ) + RecordType* rtype = fval->GetType()->AsRecordType(); + if ( ! same_type(rtype, BifType::Record::Input::TableDescription, false) ) { - zeek::reporter->Error("TableDescription argument not of right type"); + reporter->Error("TableDescription argument not of right type"); return false; } @@ -471,13 +471,13 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) auto pred = fval->GetFieldOrDefault("pred"); auto idx_val = fval->GetFieldOrDefault("idx"); - zeek::RecordType* idx = idx_val->AsType()->AsTypeType()->GetType()->AsRecordType(); + RecordType* idx = idx_val->AsType()->AsTypeType()->GetType()->AsRecordType(); - zeek::RecordTypePtr val; + RecordTypePtr val; auto val_val = fval->GetFieldOrDefault("val"); if ( val_val ) - val = val_val->AsType()->AsTypeType()->GetType(); + val = val_val->AsType()->AsTypeType()->GetType(); auto dst = fval->GetFieldOrDefault("destination"); @@ -490,21 +490,21 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) { if ( j >= num ) { - zeek::reporter->Error("Input stream %s: Table type has more indexes than index definition", stream_name.c_str()); + reporter->Error("Input stream %s: Table type has more indexes than index definition", stream_name.c_str()); return false; } if ( ! same_type(idx->GetFieldType(j), tl[j]) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; idx->GetFieldType(j)->Describe(&desc1); tl[j]->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Table type does not match index type. Need type '%s':%s, got '%s':%s", - stream_name.c_str(), - zeek::type_name(idx->GetFieldType(j)->Tag()), desc1.Description(), - zeek::type_name(tl[j]->Tag()), desc2.Description()); + reporter->Error("Input stream %s: Table type does not match index type. Need type '%s':%s, got '%s':%s", + stream_name.c_str(), + type_name(idx->GetFieldType(j)->Tag()), desc1.Description(), + type_name(tl[j]->Tag()), desc2.Description()); return false; } @@ -512,7 +512,7 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) if ( num != j ) { - zeek::reporter->Error("Input stream %s: Table has less elements than index definition", stream_name.c_str()); + reporter->Error("Input stream %s: Table has less elements than index definition", stream_name.c_str()); return false; } @@ -523,10 +523,10 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) { if ( destination_is_set ) { - zeek::reporter->Error("Input stream %s: 'destination' field is a set, " - "but the 'val' field was also specified " - "(did you mean to use a table instead of a set?)", - stream_name.data()); + reporter->Error("Input stream %s: 'destination' field is a set, " + "but the 'val' field was also specified " + "(did you mean to use a table instead of a set?)", + stream_name.data()); return false; } else @@ -536,12 +536,12 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) if ( ! same_type(table_yield, compare_type) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; compare_type->Describe(&desc1); table_yield->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Table type does not match value type. Need type '%s', got '%s'", - stream_name.c_str(), desc1.Description(), desc2.Description()); + reporter->Error("Input stream %s: Table type does not match value type. Need type '%s', got '%s'", + stream_name.c_str(), desc1.Description(), desc2.Description()); return false; } } @@ -550,24 +550,24 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) { if ( ! destination_is_set ) { - zeek::reporter->Error("Input stream %s: 'destination' field is a table," - " but 'val' field is not provided" - " (did you mean to use a set instead of a table?)", - stream_name.c_str()); + reporter->Error("Input stream %s: 'destination' field is a table," + " but 'val' field is not provided" + " (did you mean to use a set instead of a table?)", + stream_name.c_str()); return false; } } auto event_val = fval->GetFieldOrDefault("ev"); - zeek::Func* event = event_val ? event_val->AsFunc() : nullptr; + Func* event = event_val ? event_val->AsFunc() : nullptr; if ( event ) { const auto& etype = event->GetType(); - if ( etype->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( etype->Flavor() != FUNC_FLAVOR_EVENT ) { - zeek::reporter->Error("Input stream %s: Stream event is a function, not an event", stream_name.c_str()); + reporter->Error("Input stream %s: Stream event is a function, not an event", stream_name.c_str()); return false; } @@ -576,34 +576,34 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) if ( args.size() != required_arg_count ) { - zeek::reporter->Error("Input stream %s: Table event must take %zu arguments", - stream_name.c_str(), required_arg_count); + reporter->Error("Input stream %s: Table event must take %zu arguments", + stream_name.c_str(), required_arg_count); return false; } - if ( ! same_type(args[0], zeek::BifType::Record::Input::TableDescription, false) ) + if ( ! same_type(args[0], BifType::Record::Input::TableDescription, false) ) { - zeek::reporter->Error("Input stream %s: Table event's first attribute must be of type Input::TableDescription", - stream_name.c_str()); + reporter->Error("Input stream %s: Table event's first attribute must be of type Input::TableDescription", + stream_name.c_str()); return false; } - if ( ! same_type(args[1], zeek::BifType::Enum::Input::Event, false) ) + if ( ! same_type(args[1], BifType::Enum::Input::Event, false) ) { - zeek::reporter->Error("Input stream %s: Table event's second attribute must be of type Input::Event", + reporter->Error("Input stream %s: Table event's second attribute must be of type Input::Event", stream_name.c_str()); return false; } if ( ! same_type(args[2], idx) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; idx->Describe(&desc1); args[2]->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Table event's index attributes do not match. Need '%s', got '%s'", - stream_name.c_str(), - desc1.Description(), desc2.Description()); + reporter->Error("Input stream %s: Table event's index attributes do not match. Need '%s', got '%s'", + stream_name.c_str(), + desc1.Description(), desc2.Description()); return false; } @@ -611,28 +611,28 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) { if ( want_record->InternalInt() == 1 && val && ! same_type(args[3], val) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; val->Describe(&desc1); args[3]->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Table event's value attributes do not match. Need '%s', got '%s'", - stream_name.c_str(), desc1.Description(), desc2.Description()); + reporter->Error("Input stream %s: Table event's value attributes do not match. Need '%s', got '%s'", + stream_name.c_str(), desc1.Description(), desc2.Description()); return false; } else if ( want_record->InternalInt() == 0 && val && !same_type(args[3], val->GetFieldType(0) ) ) { - zeek::ODesc desc1; - zeek::ODesc desc2; + ODesc desc1; + ODesc desc2; val->GetFieldType(0)->Describe(&desc1); args[3]->Describe(&desc2); - zeek::reporter->Error("Input stream %s: Table event's value attribute does not match. Need '%s', got '%s'", - stream_name.c_str(), desc1.Description(), desc2.Description()); + reporter->Error("Input stream %s: Table event's value attribute does not match. Need '%s', got '%s'", + stream_name.c_str(), desc1.Description(), desc2.Description()); return false; } else if ( ! val ) { - zeek::reporter->Error("Encountered a null value when creating a table stream"); + reporter->Error("Encountered a null value when creating a table stream"); } } @@ -640,7 +640,7 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) } auto error_event_val = fval->GetFieldOrDefault("error_ev"); - zeek::Func* error_event = error_event_val ? error_event_val->AsFunc() : nullptr; + Func* error_event = error_event_val ? error_event_val->AsFunc() : nullptr; if ( ! CheckErrorEventTypes(stream_name, error_event, true) ) return false; @@ -652,13 +652,13 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) int idxfields = fieldsV.size(); if ( val ) // if we are not a set - status = status || ! UnrollRecordType(&fieldsV, val.get(), "", zeek::BifConst::Input::accept_unsupported_types); + status = status || ! UnrollRecordType(&fieldsV, val.get(), "", BifConst::Input::accept_unsupported_types); int valfields = fieldsV.size() - idxfields; if ( (valfields > 1) && (want_record->InternalInt() != 1) ) { - zeek::reporter->Error("Input stream %s: Stream does not want a record (want_record=F), but has more then one value field.", + reporter->Error("Input stream %s: Stream does not want a record (want_record=F), but has more then one value field.", stream_name.c_str()); for ( auto& f : fieldsV ) delete f; return false; @@ -669,7 +669,7 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) if ( status ) { - zeek::reporter->Error("Input stream %s: Problem unrolling", stream_name.c_str()); + reporter->Error("Input stream %s: Problem unrolling", stream_name.c_str()); for ( auto& f : fieldsV ) delete f; return false; } @@ -695,11 +695,11 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) stream->tab = dst.release()->AsTableVal(); stream->rtype = val.release(); stream->itype = idx->Ref()->AsRecordType(); - stream->event = event ? zeek::event_registry->Lookup(event->Name()) : nullptr; - stream->error_event = error_event ? zeek::event_registry->Lookup(error_event->Name()) : nullptr; - stream->currDict = new zeek::PDict; + stream->event = event ? event_registry->Lookup(event->Name()) : nullptr; + stream->error_event = error_event ? event_registry->Lookup(error_event->Name()) : nullptr; + stream->currDict = new PDict; stream->currDict->SetDeleteFunc(input_hash_delete_func); - stream->lastDict = new zeek::PDict; + stream->lastDict = new PDict; stream->lastDict->SetDeleteFunc(input_hash_delete_func); stream->want_record = ( want_record->InternalInt() == 1 ); @@ -708,22 +708,22 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval) readers[stream->reader] = stream; - DBG_LOG(zeek::DBG_INPUT, "Successfully created table stream %s", - stream->name.c_str()); + DBG_LOG(DBG_INPUT, "Successfully created table stream %s", + stream->name.c_str()); return true; } -bool Manager::CheckErrorEventTypes(const std::string& stream_name, const zeek::Func* ev, bool table) const +bool Manager::CheckErrorEventTypes(const std::string& stream_name, const Func* ev, bool table) const { if ( ev == nullptr ) return true; const auto& etype = ev->GetType(); - if ( etype->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( etype->Flavor() != FUNC_FLAVOR_EVENT ) { - zeek::reporter->Error("Input stream %s: Error event is a function, not an event", stream_name.c_str()); + reporter->Error("Input stream %s: Error event is a function, not an event", stream_name.c_str()); return false; } @@ -731,34 +731,34 @@ bool Manager::CheckErrorEventTypes(const std::string& stream_name, const zeek::F if ( args.size() != 3 ) { - zeek::reporter->Error("Input stream %s: Error event must take 3 arguments", stream_name.c_str()); + reporter->Error("Input stream %s: Error event must take 3 arguments", stream_name.c_str()); return false; } - if ( table && ! same_type(args[0], zeek::BifType::Record::Input::TableDescription, false) ) + if ( table && ! same_type(args[0], BifType::Record::Input::TableDescription, false) ) { - zeek::reporter->Error("Input stream %s: Error event's first attribute must be of type Input::TableDescription", + reporter->Error("Input stream %s: Error event's first attribute must be of type Input::TableDescription", stream_name.c_str()); return false; } - if ( ! table && ! same_type(args[0], zeek::BifType::Record::Input::EventDescription, false) ) + if ( ! table && ! same_type(args[0], BifType::Record::Input::EventDescription, false) ) { - zeek::reporter->Error("Input stream %s: Error event's first attribute must be of type Input::EventDescription", + reporter->Error("Input stream %s: Error event's first attribute must be of type Input::EventDescription", stream_name.c_str()); return false; } - if ( args[1]->Tag() != zeek::TYPE_STRING ) + if ( args[1]->Tag() != TYPE_STRING ) { - zeek::reporter->Error("Input stream %s: Error event's second attribute must be of type string", + reporter->Error("Input stream %s: Error event's second attribute must be of type string", stream_name.c_str()); return false; } - if ( ! same_type(args[2], zeek::BifType::Enum::Reporter::Level, false) ) + if ( ! same_type(args[2], BifType::Enum::Reporter::Level, false) ) { - zeek::reporter->Error("Input stream %s: Error event's third attribute must be of type Reporter::Level", + reporter->Error("Input stream %s: Error event's third attribute must be of type Reporter::Level", stream_name.c_str()); return false; } @@ -766,13 +766,13 @@ bool Manager::CheckErrorEventTypes(const std::string& stream_name, const zeek::F return true; } -bool Manager::CreateAnalysisStream(zeek::RecordVal* fval) +bool Manager::CreateAnalysisStream(RecordVal* fval) { - zeek::RecordType* rtype = fval->GetType()->AsRecordType(); + RecordType* rtype = fval->GetType()->AsRecordType(); - if ( ! same_type(rtype, zeek::BifType::Record::Input::AnalysisDescription, false) ) + if ( ! same_type(rtype, BifType::Record::Input::AnalysisDescription, false) ) { - zeek::reporter->Error("AnalysisDescription argument not of right type"); + reporter->Error("AnalysisDescription argument not of right type"); return false; } @@ -784,47 +784,47 @@ bool Manager::CreateAnalysisStream(zeek::RecordVal* fval) return false; } - stream->file_id = zeek::file_mgr->HashHandle(stream->name); + stream->file_id = file_mgr->HashHandle(stream->name); assert(stream->reader); // reader takes in a byte stream as the only field Field** fields = new Field*[1]; - fields[0] = new Field("bytestream", nullptr, zeek::TYPE_STRING, zeek::TYPE_VOID, false); + fields[0] = new Field("bytestream", nullptr, TYPE_STRING, TYPE_VOID, false); stream->reader->Init(1, fields); readers[stream->reader] = stream; - DBG_LOG(zeek::DBG_INPUT, "Successfully created analysis stream %s", + DBG_LOG(DBG_INPUT, "Successfully created analysis stream %s", stream->name.c_str()); return true; } -bool Manager::IsCompatibleType(zeek::Type* t, bool atomic_only) +bool Manager::IsCompatibleType(Type* t, bool atomic_only) { if ( ! t ) return false; switch ( t->Tag() ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: - case zeek::TYPE_COUNT: - case zeek::TYPE_PORT: - case zeek::TYPE_SUBNET: - case zeek::TYPE_ADDR: - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_PATTERN: + case TYPE_BOOL: + case TYPE_INT: + case TYPE_COUNT: + case TYPE_PORT: + case TYPE_SUBNET: + case TYPE_ADDR: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_PATTERN: return true; - case zeek::TYPE_RECORD: + case TYPE_RECORD: return ! atomic_only; - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( atomic_only ) return false; @@ -835,7 +835,7 @@ bool Manager::IsCompatibleType(zeek::Type* t, bool atomic_only) return IsCompatibleType(t->AsSetType()->GetIndices()->GetPureType().get(), true); } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( atomic_only ) return false; @@ -858,13 +858,13 @@ bool Manager::RemoveStream(Stream *i) if ( i->removed ) { - zeek::reporter->Warning("Stream %s is already queued for removal. Ignoring remove.", i->name.c_str()); + reporter->Warning("Stream %s is already queued for removal. Ignoring remove.", i->name.c_str()); return true; } i->removed = true; - DBG_LOG(zeek::DBG_INPUT, "Successfully queued removal of stream %s", + DBG_LOG(DBG_INPUT, "Successfully queued removal of stream %s", i->name.c_str()); i->reader->Stop(); @@ -890,12 +890,12 @@ bool Manager::RemoveStreamContinuation(ReaderFrontend* reader) if ( i == nullptr ) { - zeek::reporter->Error("Stream not found in RemoveStreamContinuation"); + reporter->Error("Stream not found in RemoveStreamContinuation"); return false; } #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Successfully executed removal of stream %s", + DBG_LOG(DBG_INPUT, "Successfully executed removal of stream %s", i->name.c_str()); #endif @@ -905,7 +905,7 @@ bool Manager::RemoveStreamContinuation(ReaderFrontend* reader) return true; } -bool Manager::UnrollRecordType(vector *fields, const zeek::RecordType *rec, +bool Manager::UnrollRecordType(vector *fields, const RecordType *rec, const string& nameprepend, bool allow_file_func) const { for ( int i = 0; i < rec->NumFields(); i++ ) @@ -919,29 +919,29 @@ bool Manager::UnrollRecordType(vector *fields, const zeek::RecordType *r // stuff that we actually cannot read :) if ( allow_file_func ) { - if ( ( rec->GetFieldType(i)->Tag() == zeek::TYPE_FILE || - rec->GetFieldType(i)->Tag() == zeek::TYPE_FUNC || - rec->GetFieldType(i)->Tag() == zeek::TYPE_OPAQUE ) && - rec->FieldDecl(i)->GetAttr(zeek::detail::ATTR_OPTIONAL) ) + if ( ( rec->GetFieldType(i)->Tag() == TYPE_FILE || + rec->GetFieldType(i)->Tag() == TYPE_FUNC || + rec->GetFieldType(i)->Tag() == TYPE_OPAQUE ) && + rec->FieldDecl(i)->GetAttr(detail::ATTR_OPTIONAL) ) { - zeek::reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", - zeek::type_name(rec->GetFieldType(i)->Tag()), name.c_str()); + reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", + type_name(rec->GetFieldType(i)->Tag()), name.c_str()); continue; } } - zeek::reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", - zeek::type_name(rec->GetFieldType(i)->Tag()), name.c_str()); + reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", + type_name(rec->GetFieldType(i)->Tag()), name.c_str()); return false; } - if ( rec->GetFieldType(i)->Tag() == zeek::TYPE_RECORD ) + if ( rec->GetFieldType(i)->Tag() == TYPE_RECORD ) { string prep = nameprepend + rec->FieldName(i) + "."; if ( rec->FieldDecl(i)->GetAttr(zeek::detail::ATTR_OPTIONAL) ) { - zeek::reporter->Info("The input framework does not support optional record fields: \"%s\"", rec->FieldName(i)); + reporter->Info("The input framework does not support optional record fields: \"%s\"", rec->FieldName(i)); return false; } @@ -956,18 +956,18 @@ bool Manager::UnrollRecordType(vector *fields, const zeek::RecordType *r { string name = nameprepend + rec->FieldName(i); const char* secondary = nullptr; - zeek::ValPtr c; - zeek::TypeTag ty = rec->GetFieldType(i)->Tag(); - zeek::TypeTag st = zeek::TYPE_VOID; + ValPtr c; + TypeTag ty = rec->GetFieldType(i)->Tag(); + TypeTag st = TYPE_VOID; bool optional = false; - if ( ty == zeek::TYPE_TABLE ) + if ( ty == TYPE_TABLE ) st = rec->GetFieldType(i)->AsSetType()->GetIndices()->GetPureType()->Tag(); - else if ( ty == zeek::TYPE_VECTOR ) + else if ( ty == TYPE_VECTOR ) st = rec->GetFieldType(i)->AsVectorType()->Yield()->Tag(); - else if ( ty == zeek::TYPE_PORT && + else if ( ty == TYPE_PORT && rec->FieldDecl(i)->GetAttr(zeek::detail::ATTR_TYPE_COLUMN) ) { // we have an annotation for the second column @@ -975,7 +975,7 @@ bool Manager::UnrollRecordType(vector *fields, const zeek::RecordType *r c = rec->FieldDecl(i)->GetAttr(zeek::detail::ATTR_TYPE_COLUMN)->GetExpr()->Eval(nullptr); assert(c); - assert(c->GetType()->Tag() == zeek::TYPE_STRING); + assert(c->GetType()->Tag() == TYPE_STRING); secondary = c->AsStringVal()->AsString()->CheckString(); } @@ -996,40 +996,40 @@ bool Manager::ForceUpdate(const string &name) Stream *i = FindStream(name); if ( i == nullptr ) { - zeek::reporter->Error("Stream %s not found", name.c_str()); + reporter->Error("Stream %s not found", name.c_str()); return false; } if ( i->removed ) { - zeek::reporter->Error("Stream %s is already queued for removal. Ignoring force update.", name.c_str()); + reporter->Error("Stream %s is already queued for removal. Ignoring force update.", name.c_str()); return false; } i->reader->Update(); #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Forcing update of stream %s", name.c_str()); + DBG_LOG(DBG_INPUT, "Forcing update of stream %s", name.c_str()); #endif return true; // update is async :( } -zeek::Val* Manager::RecordValToIndexVal(zeek::RecordVal* r) const +Val* Manager::RecordValToIndexVal(RecordVal* r) const { - zeek::ValPtr idxval; + ValPtr idxval; - zeek::RecordType *type = r->GetType()->AsRecordType(); + RecordType *type = r->GetType()->AsRecordType(); int num_fields = type->NumFields(); - if ( num_fields == 1 && type->FieldDecl(0)->type->Tag() != zeek::TYPE_RECORD ) + if ( num_fields == 1 && type->FieldDecl(0)->type->Tag() != TYPE_RECORD ) idxval = r->GetFieldOrDefault(0); else { - auto l = zeek::make_intrusive(zeek::TYPE_ANY); + auto l = make_intrusive(TYPE_ANY); for ( int j = 0 ; j < num_fields; j++ ) l->Append(r->GetFieldOrDefault(j)); @@ -1041,28 +1041,28 @@ zeek::Val* Manager::RecordValToIndexVal(zeek::RecordVal* r) const } -zeek::Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const zeek::RecordType *type, - const Value* const *vals, bool& have_error) const +Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType *type, + const Value* const *vals, bool& have_error) const { - zeek::Val* idxval; + Val* idxval; int position = 0; - if ( num_fields == 1 && type->GetFieldType(0)->Tag() != zeek::TYPE_RECORD ) + if ( num_fields == 1 && type->GetFieldType(0)->Tag() != TYPE_RECORD ) { idxval = ValueToVal(i, vals[0], type->GetFieldType(0).get(), have_error); position = 1; } else { - auto* l = new zeek::ListVal(zeek::TYPE_ANY); + auto* l = new ListVal(TYPE_ANY); for ( int j = 0 ; j < type->NumFields(); j++ ) { - if ( type->GetFieldType(j)->Tag() == zeek::TYPE_RECORD ) - l->Append({zeek::AdoptRef{}, ValueToRecordVal(i, vals, + if ( type->GetFieldType(j)->Tag() == TYPE_RECORD ) + l->Append({AdoptRef{}, ValueToRecordVal(i, vals, type->GetFieldType(j)->AsRecordType(), &position, have_error)}); else { - l->Append({zeek::AdoptRef{}, ValueToVal(i, vals[position], type->GetFieldType(j).get(), have_error)}); + l->Append({AdoptRef{}, ValueToVal(i, vals[position], type->GetFieldType(j).get(), have_error)}); position++; } } @@ -1080,8 +1080,7 @@ void Manager::SendEntry(ReaderFrontend* reader, Value* *vals) Stream *i = FindStream(reader); if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in SendEntry", - reader->Name()); + reporter->InternalWarning("Unknown reader %s in SendEntry", reader->Name()); return; } @@ -1092,17 +1091,17 @@ void Manager::SendEntry(ReaderFrontend* reader, Value* *vals) else if ( i->stream_type == EVENT_STREAM ) { - auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + auto type = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); readFields = SendEventStreamEvent(i, type.release(), vals); } else if ( i->stream_type == ANALYSIS_STREAM ) { readFields = 1; - assert(vals[0]->type == zeek::TYPE_STRING); - zeek::file_mgr->DataIn(reinterpret_cast(vals[0]->val.string_val.data), - vals[0]->val.string_val.length, - static_cast(i)->file_id, i->name); + assert(vals[0]->type == TYPE_STRING); + file_mgr->DataIn(reinterpret_cast(vals[0]->val.string_val.data), + vals[0]->val.string_val.length, + static_cast(i)->file_id, i->name); } else @@ -1167,8 +1166,8 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) } - zeek::Val* valval; - zeek::RecordVal* predidx = nullptr; + Val* valval; + RecordVal* predidx = nullptr; int position = stream->num_idx_fields; @@ -1186,7 +1185,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) // call stream first to determine if we really add / change the entry if ( stream->pred && ! convert_error ) { - zeek::EnumValPtr ev; + EnumValPtr ev; int startpos = 0; bool pred_convert_error = false; predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, pred_convert_error); @@ -1197,9 +1196,9 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) if ( ! pred_convert_error ) { if ( updated ) - ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); + ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); else - ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); bool result; if ( stream->num_val_fields > 0 ) // we have values @@ -1235,7 +1234,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) delete h; h = nullptr; - zeek::Val* idxval; + Val* idxval; if ( predidx != nullptr ) { idxval = RecordValToIndexVal(predidx); @@ -1257,24 +1256,24 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) assert(idxval); - zeek::ValPtr oldval; + ValPtr oldval; if ( updated == true ) { assert(stream->num_val_fields > 0); // in that case, we need the old value to send the event (if we send an event). - oldval = stream->tab->Find({zeek::NewRef{}, idxval}); + oldval = stream->tab->Find({NewRef{}, idxval}); } auto k = stream->tab->MakeHashKey(*idxval); if ( ! k ) - zeek::reporter->InternalError("could not hash"); + reporter->InternalError("could not hash"); InputHash* ih = new InputHash(); ih->idxkey = new zeek::detail::HashKey(k->Key(), k->Size(), k->Hash()); ih->valhash = valhash; - stream->tab->Assign({zeek::AdoptRef{}, idxval}, std::move(k), {zeek::AdoptRef{}, valval}); + stream->tab->Assign({AdoptRef{}, idxval}, std::move(k), {AdoptRef{}, valval}); if ( predidx != nullptr ) Unref(predidx); @@ -1286,7 +1285,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) if ( stream->event ) { int startpos = 0; - zeek::Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, convert_error); + Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, convert_error); if ( convert_error ) { @@ -1297,13 +1296,13 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) else if ( updated ) { // in case of update send back the old value. assert ( stream->num_val_fields > 0 ); - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); assert ( oldval != nullptr ); SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), predidx, oldval.release()); } else { - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); if ( stream->num_val_fields == 0 ) SendEvent(stream->event, 3, stream->description->Ref(), ev.release(), predidx); else @@ -1320,19 +1319,19 @@ void Manager::EndCurrentSend(ReaderFrontend* reader) if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in EndCurrentSend", + reporter->InternalWarning("Unknown reader %s in EndCurrentSend", reader->Name()); return; } #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Got EndCurrentSend stream %s", i->name.c_str()); + DBG_LOG(DBG_INPUT, "Got EndCurrentSend stream %s", i->name.c_str()); #endif if ( i->stream_type != TABLE_STREAM ) { #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "%s is event, sending end of data", i->name.c_str()); + DBG_LOG(DBG_INPUT, "%s is event, sending end of data", i->name.c_str()); #endif // just signal the end of the data source SendEndOfData(i); @@ -1343,16 +1342,16 @@ void Manager::EndCurrentSend(ReaderFrontend* reader) TableStream* stream = (TableStream*) i; // lastdict contains all deleted entries and should be empty apart from that - zeek::IterCookie *c = stream->lastDict->InitForIteration(); + IterCookie *c = stream->lastDict->InitForIteration(); stream->lastDict->MakeRobustCookie(c); InputHash* ih; zeek::detail::HashKey *lastDictIdxKey; while ( ( ih = stream->lastDict->NextEntry(lastDictIdxKey, c) ) ) { - zeek::ValPtr val; - zeek::ValPtr predidx; - zeek::EnumValPtr ev; + ValPtr val; + ValPtr predidx; + EnumValPtr ev; int startpos = 0; if ( stream->pred || stream->event ) @@ -1361,8 +1360,8 @@ void Manager::EndCurrentSend(ReaderFrontend* reader) assert(idx != nullptr); val = stream->tab->FindOrDefault(idx); assert(val != nullptr); - predidx = {zeek::AdoptRef{}, ListValToRecordVal(idx.get(), stream->itype, &startpos)}; - ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); + predidx = {AdoptRef{}, ListValToRecordVal(idx.get(), stream->itype, &startpos)}; + ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); } if ( stream->pred ) @@ -1402,11 +1401,11 @@ void Manager::EndCurrentSend(ReaderFrontend* reader) delete(stream->lastDict); stream->lastDict = stream->currDict; - stream->currDict = new zeek::PDict; + stream->currDict = new PDict; stream->currDict->SetDeleteFunc(input_hash_delete_func); #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "EndCurrentSend complete for stream %s", + DBG_LOG(DBG_INPUT, "EndCurrentSend complete for stream %s", i->name.c_str()); #endif @@ -1419,7 +1418,7 @@ void Manager::SendEndOfData(ReaderFrontend* reader) if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in SendEndOfData", + reporter->InternalWarning("Unknown reader %s in SendEndOfData", reader->Name()); return; } @@ -1431,14 +1430,14 @@ void Manager::SendEndOfData(ReaderFrontend* reader) void Manager::SendEndOfData(const Stream *i) { #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "SendEndOfData for stream %s", + DBG_LOG(DBG_INPUT, "SendEndOfData for stream %s", i->name.c_str()); #endif - SendEvent(end_of_data, 2, new zeek::StringVal(i->name.c_str()), - new zeek::StringVal(i->reader->Info().source)); + SendEvent(end_of_data, 2, new StringVal(i->name.c_str()), + new StringVal(i->reader->Info().source)); if ( i->stream_type == ANALYSIS_STREAM ) - zeek::file_mgr->EndOfFile(static_cast(i)->file_id); + file_mgr->EndOfFile(static_cast(i)->file_id); } void Manager::Put(ReaderFrontend* reader, Value* *vals) @@ -1446,12 +1445,12 @@ void Manager::Put(ReaderFrontend* reader, Value* *vals) Stream *i = FindStream(reader); if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in Put", reader->Name()); + reporter->InternalWarning("Unknown reader %s in Put", reader->Name()); return; } #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Put for stream %s", + DBG_LOG(DBG_INPUT, "Put for stream %s", i->name.c_str()); #endif @@ -1462,15 +1461,15 @@ void Manager::Put(ReaderFrontend* reader, Value* *vals) else if ( i->stream_type == EVENT_STREAM ) { - auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + auto type = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); readFields = SendEventStreamEvent(i, type.release(), vals); } else if ( i->stream_type == ANALYSIS_STREAM ) { readFields = 1; - assert(vals[0]->type == zeek::TYPE_STRING); - zeek::file_mgr->DataIn(reinterpret_cast(vals[0]->val.string_val.data), + assert(vals[0]->type == TYPE_STRING); + file_mgr->DataIn(reinterpret_cast(vals[0]->val.string_val.data), vals[0]->val.string_val.length, static_cast(i)->file_id, i->name); } @@ -1481,14 +1480,14 @@ void Manager::Put(ReaderFrontend* reader, Value* *vals) Value::delete_value_ptr_array(vals, readFields); } -int Manager::SendEventStreamEvent(Stream* i, zeek::EnumVal* type, const Value* const *vals) +int Manager::SendEventStreamEvent(Stream* i, EnumVal* type, const Value* const *vals) { assert(i); assert(i->stream_type == EVENT_STREAM); EventStream* stream = (EventStream*) i; - list out_vals; + list out_vals; Ref(stream->description); out_vals.push_back(stream->description); // no tracking, send everything with a new event... @@ -1500,7 +1499,7 @@ int Manager::SendEventStreamEvent(Stream* i, zeek::EnumVal* type, const Value* c if ( stream->want_record ) { - zeek::RecordVal * r = ValueToRecordVal(i, vals, stream->fields, &position, convert_error); + RecordVal * r = ValueToRecordVal(i, vals, stream->fields, &position, convert_error); out_vals.push_back(r); } @@ -1508,9 +1507,9 @@ int Manager::SendEventStreamEvent(Stream* i, zeek::EnumVal* type, const Value* c { for ( int j = 0; j < stream->fields->NumFields(); j++) { - zeek::Val* val = nullptr; + Val* val = nullptr; - if ( stream->fields->GetFieldType(j)->Tag() == zeek::TYPE_RECORD ) + if ( stream->fields->GetFieldType(j)->Tag() == TYPE_RECORD ) val = ValueToRecordVal(i, vals, stream->fields->GetFieldType(j)->AsRecordType(), &position, convert_error); @@ -1528,7 +1527,7 @@ int Manager::SendEventStreamEvent(Stream* i, zeek::EnumVal* type, const Value* c if ( convert_error ) { // we have an error somewhere in our out_vals. Just delete all of them. - for ( list::const_iterator it = out_vals.begin(), end = out_vals.end(); it != end; ++it ) + for ( list::const_iterator it = out_vals.begin(), end = out_vals.end(); it != end; ++it ) Unref(*it); } else @@ -1546,8 +1545,8 @@ int Manager::PutTable(Stream* i, const Value* const *vals) bool convert_error = false; - zeek::Val* idxval = ValueToIndexVal(i, stream->num_idx_fields, stream->itype, vals, convert_error); - zeek::Val* valval; + Val* idxval = ValueToIndexVal(i, stream->num_idx_fields, stream->itype, vals, convert_error); + Val* valval; int position = stream->num_idx_fields; @@ -1571,12 +1570,12 @@ int Manager::PutTable(Stream* i, const Value* const *vals) if ( stream->pred || stream->event ) { bool updated = false; - zeek::ValPtr oldval; + ValPtr oldval; if ( stream->num_val_fields > 0 ) { // in that case, we need the old value to send the event (if we send an event). - oldval = stream->tab->Find({zeek::NewRef{}, idxval}); + oldval = stream->tab->Find({NewRef{}, idxval}); } if ( oldval != nullptr ) @@ -1589,19 +1588,19 @@ int Manager::PutTable(Stream* i, const Value* const *vals) // predicate if we want the update or not if ( stream->pred ) { - zeek::EnumValPtr ev; + EnumValPtr ev; int startpos = 0; bool pred_convert_error = false; - zeek::Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, pred_convert_error); + Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, pred_convert_error); if ( pred_convert_error ) Unref(predidx); else { if ( updated ) - ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); + ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); else - ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); bool result; if ( stream->num_val_fields > 0 ) // we have values @@ -1623,13 +1622,13 @@ int Manager::PutTable(Stream* i, const Value* const *vals) } - stream->tab->Assign({zeek::NewRef{}, idxval}, {zeek::AdoptRef{}, valval}); + stream->tab->Assign({NewRef{}, idxval}, {AdoptRef{}, valval}); if ( stream->event ) { int startpos = 0; bool event_convert_error = false; - zeek::Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, event_convert_error); + Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, event_convert_error); if ( event_convert_error ) Unref(predidx); @@ -1639,14 +1638,14 @@ int Manager::PutTable(Stream* i, const Value* const *vals) { // in case of update send back the old value. assert ( stream->num_val_fields > 0 ); - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED); assert ( oldval != nullptr ); SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), predidx, oldval.release()); } else { - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW); if ( stream->num_val_fields == 0 ) SendEvent(stream->event, 3, stream->description->Ref(), ev.release(), predidx); @@ -1661,7 +1660,7 @@ int Manager::PutTable(Stream* i, const Value* const *vals) } else // no predicates or other stuff - stream->tab->Assign({zeek::NewRef{}, idxval}, {zeek::AdoptRef{}, valval}); + stream->tab->Assign({NewRef{}, idxval}, {AdoptRef{}, valval}); Unref(idxval); // not consumed by assign @@ -1674,13 +1673,12 @@ void Manager::Clear(ReaderFrontend* reader) Stream *i = FindStream(reader); if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in Clear", - reader->Name()); + reporter->InternalWarning("Unknown reader %s in Clear", reader->Name()); return; } #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Got Clear for stream %s", + DBG_LOG(DBG_INPUT, "Got Clear for stream %s", i->name.c_str()); #endif @@ -1696,7 +1694,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) Stream *i = FindStream(reader); if ( i == nullptr ) { - zeek::reporter->InternalWarning("Unknown reader %s in Delete", reader->Name()); + reporter->InternalWarning("Unknown reader %s in Delete", reader->Name()); return false; } @@ -1707,7 +1705,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) { TableStream* stream = (TableStream*) i; bool convert_error = false; - zeek::Val* idxval = ValueToIndexVal(i, stream->num_idx_fields, stream->itype, vals, convert_error); + Val* idxval = ValueToIndexVal(i, stream->num_idx_fields, stream->itype, vals, convert_error); assert(idxval != nullptr); readVals = stream->num_idx_fields + stream->num_val_fields; bool streamresult = true; @@ -1720,20 +1718,20 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) if ( stream->pred || stream->event ) { - auto val = stream->tab->FindOrDefault({zeek::NewRef{}, idxval}); + auto val = stream->tab->FindOrDefault({NewRef{}, idxval}); if ( stream->pred ) { int startpos = 0; - zeek::Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, convert_error); + Val* predidx = ValueToRecordVal(i, vals, stream->itype, &startpos, convert_error); if ( convert_error ) Unref(predidx); else { - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); - streamresult = CallPred(stream->pred, 3, ev.release(), predidx, zeek::IntrusivePtr{val}.release()); + streamresult = CallPred(stream->pred, 3, ev.release(), predidx, IntrusivePtr{val}.release()); if ( streamresult == false ) { @@ -1750,11 +1748,11 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) { Ref(idxval); assert(val != nullptr); - auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); + auto ev = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); if ( stream->num_val_fields == 0 ) SendEvent(stream->event, 3, stream->description->Ref(), ev.release(), idxval); else - SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), idxval, zeek::IntrusivePtr{val}.release()); + SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), idxval, IntrusivePtr{val}.release()); } } @@ -1768,7 +1766,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) else if ( i->stream_type == EVENT_STREAM ) { - auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); + auto type = BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED); readVals = SendEventStreamEvent(i, type.release(), vals); success = true; } @@ -1789,7 +1787,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals) return success; } -bool Manager::CallPred(zeek::Func* pred_func, const int numvals, ...) const +bool Manager::CallPred(Func* pred_func, const int numvals, ...) const { bool result = false; zeek::Args vl; @@ -1798,7 +1796,7 @@ bool Manager::CallPred(zeek::Func* pred_func, const int numvals, ...) const va_list lP; va_start(lP, numvals); for ( int i = 0; i < numvals; i++ ) - vl.emplace_back(zeek::AdoptRef{}, va_arg(lP, zeek::Val*)); + vl.emplace_back(AdoptRef{}, va_arg(lP, Val*)); va_end(lP); @@ -1810,51 +1808,51 @@ bool Manager::CallPred(zeek::Func* pred_func, const int numvals, ...) const return result; } -void Manager::SendEvent(zeek::EventHandlerPtr ev, const int numvals, ...) const +void Manager::SendEvent(EventHandlerPtr ev, const int numvals, ...) const { zeek::Args vl; vl.reserve(numvals); #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "SendEvent with %d vals", + DBG_LOG(DBG_INPUT, "SendEvent with %d vals", numvals); #endif va_list lP; va_start(lP, numvals); for ( int i = 0; i < numvals; i++ ) - vl.emplace_back(zeek::AdoptRef{}, va_arg(lP, zeek::Val*)); + vl.emplace_back(AdoptRef{}, va_arg(lP, Val*)); va_end(lP); if ( ev ) - zeek::event_mgr.Enqueue(ev, std::move(vl), zeek::util::detail::SOURCE_LOCAL); + event_mgr.Enqueue(ev, std::move(vl), util::detail::SOURCE_LOCAL); } -void Manager::SendEvent(zeek::EventHandlerPtr ev, list events) const +void Manager::SendEvent(EventHandlerPtr ev, list events) const { zeek::Args vl; vl.reserve(events.size()); #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "SendEvent with %" PRIuPTR " vals (list)", + DBG_LOG(DBG_INPUT, "SendEvent with %" PRIuPTR " vals (list)", events.size()); #endif - for ( list::iterator i = events.begin(); i != events.end(); i++ ) - vl.emplace_back(zeek::AdoptRef{}, *i); + for ( list::iterator i = events.begin(); i != events.end(); i++ ) + vl.emplace_back(AdoptRef{}, *i); if ( ev ) - zeek::event_mgr.Enqueue(ev, std::move(vl), zeek::util::detail::SOURCE_LOCAL); + event_mgr.Enqueue(ev, std::move(vl), util::detail::SOURCE_LOCAL); } // Convert a bro list value to a bro record value. // I / we could think about moving this functionality to val.cc -zeek::RecordVal* Manager::ListValToRecordVal(zeek::ListVal* list, zeek::RecordType *request_type, int* position) const +RecordVal* Manager::ListValToRecordVal(ListVal* list, RecordType *request_type, int* position) const { assert(position != nullptr); // we need the pointer to point to data; - auto* rec = new zeek::RecordVal({zeek::NewRef{}, request_type}); + auto* rec = new RecordVal({NewRef{}, request_type}); assert(list != nullptr); int maxpos = list->Length(); @@ -1863,8 +1861,8 @@ zeek::RecordVal* Manager::ListValToRecordVal(zeek::ListVal* list, zeek::RecordTy { assert ( (*position) <= maxpos ); - zeek::Val* fieldVal = nullptr; - if ( request_type->GetFieldType(i)->Tag() == zeek::TYPE_RECORD ) + Val* fieldVal = nullptr; + if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD ) fieldVal = ListValToRecordVal(list, request_type->GetFieldType(i)->AsRecordType(), position); else { @@ -1872,26 +1870,26 @@ zeek::RecordVal* Manager::ListValToRecordVal(zeek::ListVal* list, zeek::RecordTy (*position)++; } - rec->Assign(i, {zeek::NewRef{}, fieldVal}); + rec->Assign(i, {NewRef{}, fieldVal}); } return rec; } // Convert a threading value to a record value -zeek::RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *vals, - zeek::RecordType *request_type, int* position, bool& have_error) const +RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *vals, + RecordType *request_type, int* position, bool& have_error) const { assert(position != nullptr); // we need the pointer to point to data. - auto* rec = new zeek::RecordVal({zeek::NewRef{}, request_type}); + auto* rec = new RecordVal({NewRef{}, request_type}); for ( int i = 0; i < request_type->NumFields(); i++ ) { - zeek::Val* fieldVal = nullptr; - if ( request_type->GetFieldType(i)->Tag() == zeek::TYPE_RECORD ) + Val* fieldVal = nullptr; + if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD ) fieldVal = ValueToRecordVal(stream, vals, request_type->GetFieldType(i)->AsRecordType(), position, have_error); - else if ( request_type->GetFieldType(i)->Tag() == zeek::TYPE_FILE || - request_type->GetFieldType(i)->Tag() == zeek::TYPE_FUNC ) + else if ( request_type->GetFieldType(i)->Tag() == TYPE_FILE || + request_type->GetFieldType(i)->Tag() == TYPE_FUNC ) { // If those two unsupported types are encountered here, they have // been let through by the type checking. @@ -1909,7 +1907,7 @@ zeek::RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* co } if ( fieldVal ) - rec->Assign(i, {zeek::AdoptRef{}, fieldVal}); + rec->Assign(i, {AdoptRef{}, fieldVal}); } return rec; @@ -1923,34 +1921,34 @@ int Manager::GetValueLength(const Value* val) const int length = 0; switch (val->type) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_INT: length += sizeof(val->val.int_val); break; - case zeek::TYPE_COUNT: + case TYPE_COUNT: length += sizeof(val->val.uint_val); break; - case zeek::TYPE_PORT: + case TYPE_PORT: length += sizeof(val->val.port_val.port); length += sizeof(val->val.port_val.proto); break; - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: length += sizeof(val->val.double_val); break; - case zeek::TYPE_STRING: - case zeek::TYPE_ENUM: + case TYPE_STRING: + case TYPE_ENUM: { length += val->val.string_val.length + 1; break; } - case zeek::TYPE_ADDR: + case TYPE_ADDR: { switch ( val->val.addr_val.family ) { case IPv4: @@ -1965,7 +1963,7 @@ int Manager::GetValueLength(const Value* val) const } break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { switch ( val->val.subnet_val.prefix.family ) { case IPv4: @@ -1982,20 +1980,20 @@ int Manager::GetValueLength(const Value* val) const } break; - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { length += strlen(val->val.pattern_text_val) + 1; break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { for ( int i = 0; i < val->val.set_val.size; i++ ) length += GetValueLength(val->val.set_val.vals[i]); break; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { int j = val->val.vector_val.size; for ( int i = 0; i < j; i++ ) @@ -2004,7 +2002,7 @@ int Manager::GetValueLength(const Value* val) const } default: - zeek::reporter->InternalError("unsupported type %d for GetValueLength", val->type); + reporter->InternalError("unsupported type %d for GetValueLength", val->type); } return length; @@ -2018,16 +2016,16 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const assert( val->present ); // presence has to be checked elsewhere switch ( val->type ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_INT: memcpy(data+startpos, (const void*) &(val->val.int_val), sizeof(val->val.int_val)); return sizeof(val->val.int_val); - case zeek::TYPE_COUNT: + case TYPE_COUNT: memcpy(data+startpos, (const void*) &(val->val.uint_val), sizeof(val->val.uint_val)); return sizeof(val->val.uint_val); - case zeek::TYPE_PORT: + case TYPE_PORT: { int length = 0; memcpy(data+startpos, (const void*) &(val->val.port_val.port), @@ -2040,15 +2038,15 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const } - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: memcpy(data+startpos, (const void*) &(val->val.double_val), sizeof(val->val.double_val)); return sizeof(val->val.double_val); - case zeek::TYPE_STRING: - case zeek::TYPE_ENUM: + case TYPE_STRING: + case TYPE_ENUM: { memcpy(data+startpos, val->val.string_val.data, val->val.string_val.length); // Add a \0 to the end. To be able to hash zero-length @@ -2057,7 +2055,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const return val->val.string_val.length + 1; } - case zeek::TYPE_ADDR: + case TYPE_ADDR: { int length = 0; switch ( val->val.addr_val.family ) { @@ -2078,7 +2076,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const return length; } - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { int length = 0; switch ( val->val.subnet_val.prefix.family ) { @@ -2106,7 +2104,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const return length; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { // include null-terminator int length = strlen(val->val.pattern_text_val) + 1; @@ -2114,7 +2112,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const return length; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { int length = 0; int j = val->val.set_val.size; @@ -2124,7 +2122,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const return length; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { int length = 0; int j = val->val.vector_val.size; @@ -2135,7 +2133,7 @@ int Manager::CopyValue(char *data, const int startpos, const Value* val) const } default: - zeek::reporter->InternalError("unsupported type %d for CopyValue", val->type); + reporter->InternalError("unsupported type %d for CopyValue", val->type); return 0; } @@ -2190,14 +2188,14 @@ zeek::detail::HashKey* Manager::HashValues(const int num_elements, const Value* // have_error is a reference to a boolean which is set to true as soon as an error occurs. // When have_error is set to true at the beginning of the function, it is assumed that // an error already occurred in the past and processing is aborted. -zeek::Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::Type* request_type, bool& have_error) const +Val* Manager::ValueToVal(const Stream* i, const Value* val, Type* request_type, bool& have_error) const { if ( have_error ) return nullptr; - if ( request_type->Tag() != zeek::TYPE_ANY && request_type->Tag() != val->type ) + if ( request_type->Tag() != TYPE_ANY && request_type->Tag() != val->type ) { - zeek::reporter->InternalError("Typetags don't match: %d vs %d in stream %s", request_type->Tag(), val->type, i->name.c_str()); + reporter->InternalError("Typetags don't match: %d vs %d in stream %s", request_type->Tag(), val->type, i->name.c_str()); return nullptr; } @@ -2205,117 +2203,117 @@ zeek::Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::Type* re return nullptr; // unset field switch ( val->type ) { - case zeek::TYPE_BOOL: - return zeek::val_mgr->Bool(val->val.int_val)->Ref(); + case TYPE_BOOL: + return val_mgr->Bool(val->val.int_val)->Ref(); - case zeek::TYPE_INT: - return zeek::val_mgr->Int(val->val.int_val).release(); + case TYPE_INT: + return val_mgr->Int(val->val.int_val).release(); - case zeek::TYPE_COUNT: - return zeek::val_mgr->Count(val->val.int_val).release(); + case TYPE_COUNT: + return val_mgr->Count(val->val.int_val).release(); - case zeek::TYPE_DOUBLE: - return new zeek::DoubleVal(val->val.double_val); + case TYPE_DOUBLE: + return new DoubleVal(val->val.double_val); - case zeek::TYPE_TIME: - return new zeek::TimeVal(val->val.double_val); + case TYPE_TIME: + return new TimeVal(val->val.double_val); - case zeek::TYPE_INTERVAL: - return new zeek::IntervalVal(val->val.double_val); + case TYPE_INTERVAL: + return new IntervalVal(val->val.double_val); - case zeek::TYPE_STRING: + case TYPE_STRING: { - zeek::String *s = new zeek::String((const u_char*)val->val.string_val.data, val->val.string_val.length, true); - return new zeek::StringVal(s); + String *s = new String((const u_char*)val->val.string_val.data, val->val.string_val.length, true); + return new StringVal(s); } - case zeek::TYPE_PORT: - return zeek::val_mgr->Port(val->val.port_val.port, val->val.port_val.proto)->Ref(); + case TYPE_PORT: + return val_mgr->Port(val->val.port_val.port, val->val.port_val.proto)->Ref(); - case zeek::TYPE_ADDR: + case TYPE_ADDR: { - zeek::IPAddr* addr = nullptr; + IPAddr* addr = nullptr; switch ( val->val.addr_val.family ) { case IPv4: - addr = new zeek::IPAddr(val->val.addr_val.in.in4); + addr = new IPAddr(val->val.addr_val.in.in4); break; case IPv6: - addr = new zeek::IPAddr(val->val.addr_val.in.in6); + addr = new IPAddr(val->val.addr_val.in.in6); break; default: assert(false); } - auto* addrval = new zeek::AddrVal(*addr); + auto* addrval = new AddrVal(*addr); delete addr; return addrval; } - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { - zeek::IPAddr* addr = nullptr; + IPAddr* addr = nullptr; switch ( val->val.subnet_val.prefix.family ) { case IPv4: - addr = new zeek::IPAddr(val->val.subnet_val.prefix.in.in4); + addr = new IPAddr(val->val.subnet_val.prefix.in.in4); break; case IPv6: - addr = new zeek::IPAddr(val->val.subnet_val.prefix.in.in6); + addr = new IPAddr(val->val.subnet_val.prefix.in.in6); break; default: assert(false); } - auto* subnetval = new zeek::SubNetVal(*addr, val->val.subnet_val.length); + auto* subnetval = new SubNetVal(*addr, val->val.subnet_val.length); delete addr; return subnetval; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { - auto* re = new zeek::RE_Matcher(val->val.pattern_text_val); + auto* re = new RE_Matcher(val->val.pattern_text_val); re->Compile(); - return new zeek::PatternVal(re); + return new PatternVal(re); } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { // all entries have to have the same type... const auto& type = request_type->AsTableType()->GetIndices()->GetPureType(); - auto set_index = zeek::make_intrusive(type); + auto set_index = make_intrusive(type); set_index->Append(type); - auto s = zeek::make_intrusive(std::move(set_index), nullptr); - auto* t = new zeek::TableVal(std::move(s)); + auto s = make_intrusive(std::move(set_index), nullptr); + auto* t = new TableVal(std::move(s)); for ( int j = 0; j < val->val.set_val.size; j++ ) { - zeek::Val* assignval = ValueToVal(i, val->val.set_val.vals[j], type.get(), have_error); + Val* assignval = ValueToVal(i, val->val.set_val.vals[j], type.get(), have_error); - t->Assign({zeek::AdoptRef{}, assignval}, nullptr); + t->Assign({AdoptRef{}, assignval}, nullptr); } return t; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { // all entries have to have the same type... const auto& type = request_type->AsVectorType()->Yield(); - auto vt = zeek::make_intrusive(type); - auto v = zeek::make_intrusive(std::move(vt)); + auto vt = make_intrusive(type); + auto v = make_intrusive(std::move(vt)); for ( int j = 0; j < val->val.vector_val.size; j++ ) { auto el = ValueToVal(i, val->val.vector_val.vals[j], type.get(), have_error); - v->Assign(j, {zeek::AdoptRef{}, el}); + v->Assign(j, {AdoptRef{}, el}); } return v.release(); } - case zeek::TYPE_ENUM: { + case TYPE_ENUM: { // Convert to string first to not have to deal with missing // \0's... string enum_string(val->val.string_val.data, val->val.string_val.length); @@ -2341,7 +2339,7 @@ zeek::Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::Type* re } default: - zeek::reporter->InternalError("Unsupported type for input_read in stream %s", i->name.c_str()); + reporter->InternalError("Unsupported type for input_read in stream %s", i->name.c_str()); } assert(false); @@ -2388,7 +2386,7 @@ void Manager::Info(ReaderFrontend* reader, const char* msg) const Stream *i = FindStream(reader); if ( !i ) { - zeek::reporter->Error("Stream not found in Info; lost message: %s", msg); + reporter->Error("Stream not found in Info; lost message: %s", msg); return; } @@ -2400,7 +2398,7 @@ void Manager::Warning(ReaderFrontend* reader, const char* msg) const Stream *i = FindStream(reader); if ( !i ) { - zeek::reporter->Error("Stream not found in Warning; lost message: %s", msg); + reporter->Error("Stream not found in Warning; lost message: %s", msg); return; } @@ -2412,7 +2410,7 @@ void Manager::Error(ReaderFrontend* reader, const char* msg) const Stream *i = FindStream(reader); if ( !i ) { - zeek::reporter->Error("Stream not found in Error; lost message: %s", msg); + reporter->Error("Stream not found in Error; lost message: %s", msg); return; } @@ -2458,34 +2456,34 @@ void Manager::ErrorHandler(const Stream* i, ErrorType et, bool reporter_send, co int n = vasprintf(&buf, fmt, ap); if ( n < 0 || buf == nullptr ) { - zeek::reporter->InternalError("Could not format error message %s for stream %s", fmt, i->name.c_str()); + reporter->InternalError("Could not format error message %s for stream %s", fmt, i->name.c_str()); return; } // send our script level error event if ( i->error_event ) { - zeek::EnumValPtr ev; + EnumValPtr ev; switch (et) { case ErrorType::INFO: - ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::INFO); + ev = BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::INFO); break; case ErrorType::WARNING: - ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::WARNING); + ev = BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::WARNING); break; case ErrorType::ERROR: - ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::ERROR); + ev = BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::ERROR); break; default: - zeek::reporter->InternalError("Unknown error type while trying to report input error %s", fmt); + reporter->InternalError("Unknown error type while trying to report input error %s", fmt); __builtin_unreachable(); } - auto* message = new zeek::StringVal(buf); + auto* message = new StringVal(buf); SendEvent(i->error_event, 3, i->description->Ref(), message, ev.release()); } @@ -2494,19 +2492,19 @@ void Manager::ErrorHandler(const Stream* i, ErrorType et, bool reporter_send, co switch (et) { case ErrorType::INFO: - zeek::reporter->Info("%s", buf); + reporter->Info("%s", buf); break; case ErrorType::WARNING: - zeek::reporter->Warning("%s", buf); + reporter->Warning("%s", buf); break; case ErrorType::ERROR: - zeek::reporter->Error("%s", buf); + reporter->Error("%s", buf); break; default: - zeek::reporter->InternalError("Unknown error type while trying to report input error %s", fmt); + reporter->InternalError("Unknown error type while trying to report input error %s", fmt); } } diff --git a/src/input/Manager.h b/src/input/Manager.h index 91bbe6ef3d..232c85b2b6 100644 --- a/src/input/Manager.h +++ b/src/input/Manager.h @@ -44,7 +44,7 @@ public: * This method corresponds directly to the internal BiF defined in * input.bif, which just forwards here. */ - bool CreateTableStream(zeek::RecordVal* description); + bool CreateTableStream(RecordVal* description); /** * Creates a new input stream which sends events for read input data. @@ -55,7 +55,7 @@ public: * This method corresponds directly to the internal BiF defined in * input.bif, which just forwards here. */ - bool CreateEventStream(zeek::RecordVal* description); + bool CreateEventStream(RecordVal* description); /** * Creates a new input stream which will forward the data from the data @@ -67,7 +67,7 @@ public: * @param description A record of the script type \c * Input::AnalysisDescription */ - bool CreateAnalysisStream(zeek::RecordVal* description); + bool CreateAnalysisStream(RecordVal* description); /** * Force update on a input stream. Forces a re-read of the whole @@ -111,7 +111,7 @@ public: * * @return True if the type is compatible with the input framework. */ - static bool IsCompatibleType(zeek::Type* t, bool atomic_only=false); + static bool IsCompatibleType(Type* t, bool atomic_only=false); protected: friend class ReaderFrontend; @@ -143,7 +143,7 @@ protected: // Instantiates a new ReaderBackend of the given type (note that // doing so creates a new thread!). - ReaderBackend* CreateBackend(ReaderFrontend* frontend, zeek::EnumVal* tag); + ReaderBackend* CreateBackend(ReaderFrontend* frontend, EnumVal* tag); // Function called from the ReaderBackend to notify the manager that // a stream has been removed or a stream has been closed. Used to @@ -180,12 +180,12 @@ private: // protected definitions are wrappers around this function. bool RemoveStream(Stream* i); - bool CreateStream(Stream*, zeek::RecordVal* description); + bool CreateStream(Stream*, RecordVal* description); // Check if the types of the error_ev event are correct. If table is // true, check for tablestream type, otherwhise check for eventstream // type. - bool CheckErrorEventTypes(const std::string& stream_name, const zeek::Func* error_event, bool table) const; + bool CheckErrorEventTypes(const std::string& stream_name, const Func* error_event, bool table) const; // SendEntry implementation for Table stream. int SendEntryTable(Stream* i, const threading::Value* const *vals); @@ -194,22 +194,22 @@ private: int PutTable(Stream* i, const threading::Value* const *vals); // SendEntry and Put implementation for Event stream. - int SendEventStreamEvent(Stream* i, zeek::EnumVal* type, const threading::Value* const *vals); + int SendEventStreamEvent(Stream* i, EnumVal* type, const threading::Value* const *vals); // Check if a record is made up of compatible types and return a list // of all fields that are in the record in order. Recursively unrolls // records - bool UnrollRecordType(std::vector *fields, const zeek::RecordType *rec, const std::string& nameprepend, bool allow_file_func) const; + bool UnrollRecordType(std::vector *fields, const RecordType *rec, const std::string& nameprepend, bool allow_file_func) const; // Send events - void SendEvent(zeek::EventHandlerPtr ev, const int numvals, ...) const; - void SendEvent(zeek::EventHandlerPtr ev, std::list events) const; + void SendEvent(EventHandlerPtr ev, const int numvals, ...) const; + void SendEvent(EventHandlerPtr ev, std::list events) const; // Implementation of SendEndOfData (send end_of_data event). void SendEndOfData(const Stream *i); // Call predicate function and return result. - bool CallPred(zeek::Func* pred_func, const int numvals, ...) const; + bool CallPred(Func* pred_func, const int numvals, ...) const; // Get a hashkey for a set of threading::Values. zeek::detail::HashKey* HashValues(const int num_elements, const threading::Value* const *vals) const; @@ -222,19 +222,19 @@ private: int CopyValue(char *data, const int startpos, const threading::Value* val) const; // Convert Threading::Value to an internal Bro Type (works with Records). - zeek::Val* ValueToVal(const Stream* i, const threading::Value* val, zeek::Type* request_type, bool& have_error) const; + Val* ValueToVal(const Stream* i, const threading::Value* val, Type* request_type, bool& have_error) const; // Convert Threading::Value to an internal Bro list type. - zeek::Val* ValueToIndexVal(const Stream* i, int num_fields, const zeek::RecordType* type, const threading::Value* const *vals, bool& have_error) const; + Val* ValueToIndexVal(const Stream* i, int num_fields, const RecordType* type, const threading::Value* const *vals, bool& have_error) const; // Converts a threading::value to a record type. Mostly used by // ValueToVal. - zeek::RecordVal* ValueToRecordVal(const Stream* i, const threading::Value* const *vals, zeek::RecordType *request_type, int* position, bool& have_error) const; + RecordVal* ValueToRecordVal(const Stream* i, const threading::Value* const *vals, RecordType *request_type, int* position, bool& have_error) const; - zeek::Val* RecordValToIndexVal(zeek::RecordVal *r) const; + Val* RecordValToIndexVal(RecordVal *r) const; // Converts a Bro ListVal to a RecordVal given the record type. - zeek::RecordVal* ListValToRecordVal(zeek::ListVal* list, zeek::RecordType *request_type, int* position) const; + RecordVal* ListValToRecordVal(ListVal* list, RecordType *request_type, int* position) const; // Internally signal errors, warnings, etc. // These are sent on to input scriptland and reporter.log @@ -253,7 +253,7 @@ private: std::map readers; - zeek::EventHandlerPtr end_of_data; + EventHandlerPtr end_of_data; }; } // namespace input diff --git a/src/input/ReaderBackend.cc b/src/input/ReaderBackend.cc index 14dfa4262e..1e05210877 100644 --- a/src/input/ReaderBackend.cc +++ b/src/input/ReaderBackend.cc @@ -63,7 +63,7 @@ public: ReaderErrorMessage(ReaderFrontend* reader, Type arg_type, const char* arg_msg) : threading::OutputMessage("ReaderErrorMessage", reader) - { type = arg_type; msg = zeek::util::copy_string(arg_msg); } + { type = arg_type; msg = util::copy_string(arg_msg); } ~ReaderErrorMessage() override { delete [] msg; } diff --git a/src/input/ReaderBackend.h b/src/input/ReaderBackend.h index e7acc222ec..bf9adefc99 100644 --- a/src/input/ReaderBackend.h +++ b/src/input/ReaderBackend.h @@ -75,7 +75,7 @@ public: struct ReaderInfo { // Structure takes ownership of the strings. - typedef std::map config_map; + typedef std::map config_map; /** * A string left to the interpretation of the reader @@ -111,12 +111,12 @@ public: ReaderInfo(const ReaderInfo& other) { - source = other.source ? zeek::util::copy_string(other.source) : nullptr; - name = other.name ? zeek::util::copy_string(other.name) : nullptr; + source = other.source ? util::copy_string(other.source) : nullptr; + name = other.name ? util::copy_string(other.name) : nullptr; mode = other.mode; for ( config_map::const_iterator i = other.config.begin(); i != other.config.end(); i++ ) - config.insert(std::make_pair(zeek::util::copy_string(i->first), zeek::util::copy_string(i->second))); + config.insert(std::make_pair(util::copy_string(i->first), util::copy_string(i->second))); } ~ReaderInfo() diff --git a/src/input/ReaderFrontend.cc b/src/input/ReaderFrontend.cc index cd1367dc6d..53b14a04eb 100644 --- a/src/input/ReaderFrontend.cc +++ b/src/input/ReaderFrontend.cc @@ -34,13 +34,13 @@ public: bool Process() override { return Object()->Update(); } }; -ReaderFrontend::ReaderFrontend(const ReaderBackend::ReaderInfo& arg_info, zeek::EnumVal* type) +ReaderFrontend::ReaderFrontend(const ReaderBackend::ReaderInfo& arg_info, EnumVal* type) { disabled = initialized = false; info = new ReaderBackend::ReaderInfo(arg_info); const char* t = type->GetType()->AsEnumType()->Lookup(type->InternalInt()); - name = zeek::util::copy_string(zeek::util::fmt("%s/%s", arg_info.source, t)); + name = util::copy_string(util::fmt("%s/%s", arg_info.source, t)); backend = input_mgr->CreateBackend(this, type); assert(backend); @@ -69,7 +69,7 @@ void ReaderFrontend::Init(const int arg_num_fields, return; if ( initialized ) - zeek::reporter->InternalError("reader initialize twice"); + reporter->InternalError("reader initialize twice"); num_fields = arg_num_fields; fields = arg_fields; @@ -85,7 +85,7 @@ void ReaderFrontend::Update() if ( ! initialized ) { - zeek::reporter->Error("Tried to call update on uninitialized reader"); + reporter->Error("Tried to call update on uninitialized reader"); return; } diff --git a/src/input/ReaderFrontend.h b/src/input/ReaderFrontend.h index 4c2e231dae..007f60bbc3 100644 --- a/src/input/ReaderFrontend.h +++ b/src/input/ReaderFrontend.h @@ -32,7 +32,7 @@ public: * * Frontends must only be instantiated by the main thread. */ - ReaderFrontend(const ReaderBackend::ReaderInfo& info, zeek::EnumVal* type); + ReaderFrontend(const ReaderBackend::ReaderInfo& info, EnumVal* type); /** * Destructor. @@ -118,7 +118,7 @@ public: const threading::Field* const * Fields() const { return fields; } protected: - friend class zeek::input::Manager; + friend class Manager; private: ReaderBackend* backend; // The backend we have instanatiated. diff --git a/src/input/Tag.cc b/src/input/Tag.cc index cb4a0bd5a1..cd5d21652b 100644 --- a/src/input/Tag.cc +++ b/src/input/Tag.cc @@ -18,22 +18,22 @@ Tag& Tag::operator=(const Tag& other) return *this; } -const zeek::EnumValPtr& Tag::AsVal() const +const EnumValPtr& Tag::AsVal() const { return zeek::Tag::AsVal(input_mgr->GetTagType()); } -zeek::EnumVal* Tag::AsEnumVal() const +EnumVal* Tag::AsEnumVal() const { return AsVal().get(); } -Tag::Tag(zeek::EnumValPtr val) +Tag::Tag(EnumValPtr val) : zeek::Tag(std::move(val)) { } -Tag::Tag(zeek::EnumVal* val) - : zeek::Tag({zeek::NewRef{}, val}) +Tag::Tag(EnumVal* val) + : zeek::Tag({NewRef{}, val}) { } } // namespace zeek::input diff --git a/src/input/Tag.h b/src/input/Tag.h index 08035e2c75..69a5f4373c 100644 --- a/src/input/Tag.h +++ b/src/input/Tag.h @@ -89,16 +89,16 @@ public: * * @param etype the script-layer enum type associated with the tag. */ - const zeek::EnumValPtr& AsVal() const; + const EnumValPtr& AsVal() const; [[deprecated("Remove in v4.1. Use AsVal() instead.")]] - zeek::EnumVal* AsEnumVal() const; + EnumVal* AsEnumVal() const; static const Tag Error; protected: - friend class zeek::plugin::ComponentManager; - friend class zeek::plugin::TaggedComponent; + friend class plugin::ComponentManager; + friend class plugin::TaggedComponent; /** * Constructor. @@ -117,10 +117,10 @@ protected: * * @param val An enum value of script type \c Input::Reader. */ - explicit Tag(zeek::EnumValPtr val); + explicit Tag(EnumValPtr val); [[deprecated("Remove in v4.1. Construct from IntrusivePtr isntead.")]] - explicit Tag(zeek::EnumVal* val); + explicit Tag(EnumVal* val); }; } // namespace zeek::input diff --git a/src/iosource/Component.cc b/src/iosource/Component.cc index 8a2b6abe74..bfacdc5699 100644 --- a/src/iosource/Component.cc +++ b/src/iosource/Component.cc @@ -8,11 +8,11 @@ namespace zeek::iosource { Component::Component(const std::string& name) - : zeek::plugin::Component(zeek::plugin::component::IOSOURCE, name) + : plugin::Component(plugin::component::IOSOURCE, name) { } -Component::Component(zeek::plugin::component::Type type, const std::string& name) +Component::Component(plugin::component::Type type, const std::string& name) : plugin::Component(type, name) { } @@ -22,9 +22,9 @@ Component::~Component() } PktSrcComponent::PktSrcComponent(const std::string& arg_name, const std::string& arg_prefix, InputType arg_type, factory_callback arg_factory) - : iosource::Component(zeek::plugin::component::PKTSRC, arg_name) + : Component(plugin::component::PKTSRC, arg_name) { - zeek::util::tokenize_string(arg_prefix, ":", &prefixes); + util::tokenize_string(arg_prefix, ":", &prefixes); type = arg_type; factory = arg_factory; } @@ -65,9 +65,9 @@ PktSrcComponent::factory_callback PktSrcComponent::Factory() const return factory; } -void PktSrcComponent::DoDescribe(zeek::ODesc* d) const +void PktSrcComponent::DoDescribe(ODesc* d) const { - iosource::Component::DoDescribe(d); + Component::DoDescribe(d); std::string prefs; @@ -102,15 +102,15 @@ void PktSrcComponent::DoDescribe(zeek::ODesc* d) const break; default: - zeek::reporter->InternalError("unknown PkrSrc type"); + reporter->InternalError("unknown PkrSrc type"); } } PktDumperComponent::PktDumperComponent(const std::string& name, const std::string& arg_prefix, factory_callback arg_factory) - : zeek::plugin::Component(zeek::plugin::component::PKTDUMPER, name) + : plugin::Component(plugin::component::PKTDUMPER, name) { - zeek::util::tokenize_string(arg_prefix, ":", &prefixes); + util::tokenize_string(arg_prefix, ":", &prefixes); factory = arg_factory; } @@ -140,9 +140,9 @@ bool PktDumperComponent::HandlesPrefix(const std::string& prefix) const return false; } -void PktDumperComponent::DoDescribe(zeek::ODesc* d) const +void PktDumperComponent::DoDescribe(ODesc* d) const { - zeek::plugin::Component::DoDescribe(d); + plugin::Component::DoDescribe(d); std::string prefs; diff --git a/src/iosource/Component.h b/src/iosource/Component.h index fbde50d2ce..5f37e79dc8 100644 --- a/src/iosource/Component.h +++ b/src/iosource/Component.h @@ -16,7 +16,7 @@ namespace zeek::iosource { /** * Component description for plugins providing IOSources. */ -class Component : public zeek::plugin::Component { +class Component : public plugin::Component { public: typedef IOSource* (*factory_callback)(); @@ -43,13 +43,13 @@ protected: * @param name A descriptive name for the component. This name must * be unique across all components of this type. */ - Component(zeek::plugin::component::Type type, const std::string& name); + Component(plugin::component::Type type, const std::string& name); }; /** * Component description for plugins providing a PktSrc for packet input. */ -class PktSrcComponent : public zeek::iosource::Component { +class PktSrcComponent : public Component { public: /** * Type of input a packet source supports. @@ -113,7 +113,7 @@ public: * Generates a human-readable description of the component. This goes * into the output of \c "bro -NN". */ - void DoDescribe(zeek::ODesc* d) const override; + void DoDescribe(ODesc* d) const override; private: std::vector prefixes; @@ -127,7 +127,7 @@ private: * PktDumpers aren't IOSurces but we locate them here to keep them along with * the PktSrc. */ -class PktDumperComponent : public zeek::plugin::Component { +class PktDumperComponent : public plugin::Component { public: typedef PktDumper* (*factory_callback)(const std::string& path, bool append); @@ -160,7 +160,7 @@ public: * Generates a human-readable description of the component. This goes * into the output of \c "bro -NN". */ - void DoDescribe(zeek::ODesc* d) const override; + void DoDescribe(ODesc* d) const override; private: std::vector prefixes; diff --git a/src/iosource/Manager.cc b/src/iosource/Manager.cc index 50e831f868..aa5d01c882 100644 --- a/src/iosource/Manager.cc +++ b/src/iosource/Manager.cc @@ -25,7 +25,7 @@ namespace zeek::iosource { Manager::WakeupHandler::WakeupHandler() { if ( ! iosource_mgr->RegisterFd(flare.FD(), this) ) - zeek::reporter->FatalError("Failed to register WakeupHandler's fd with iosource_mgr"); + reporter->FatalError("Failed to register WakeupHandler's fd with iosource_mgr"); } Manager::WakeupHandler::~WakeupHandler() @@ -40,7 +40,7 @@ void Manager::WakeupHandler::Process() void Manager::WakeupHandler::Ping(const std::string& where) { - DBG_LOG(zeek::DBG_MAINLOOP, "Pinging WakeupHandler from %s", where.c_str()); + DBG_LOG(DBG_MAINLOOP, "Pinging WakeupHandler from %s", where.c_str()); flare.Fire(); } @@ -48,7 +48,7 @@ Manager::Manager() { event_queue = kqueue(); if ( event_queue == -1 ) - zeek::reporter->FatalError("Failed to initialize kqueue: %s", strerror(errno)); + reporter->FatalError("Failed to initialize kqueue: %s", strerror(errno)); } Manager::~Manager() @@ -115,7 +115,7 @@ void Manager::FindReadySources(std::vector* ready) // If there aren't any sources and exit_only_after_terminate is false, just // return an empty set of sources. We want the main loop to end. - if ( Size() == 0 && ( ! zeek::BifConst::exit_only_after_terminate || zeek::run_state::terminating ) ) + if ( Size() == 0 && ( ! BifConst::exit_only_after_terminate || run_state::terminating ) ) return; double timeout = -1; @@ -166,7 +166,7 @@ void Manager::FindReadySources(std::vector* ready) } else { - if ( ! zeek::run_state::pseudo_realtime ) + if ( ! run_state::pseudo_realtime ) // A pcap file is always ready to process unless it's suspended ready->push_back(pkt_src); } @@ -174,7 +174,7 @@ void Manager::FindReadySources(std::vector* ready) } } - DBG_LOG(zeek::DBG_MAINLOOP, "timeout: %f ready size: %zu time_to_poll: %d\n", + DBG_LOG(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 @@ -195,7 +195,7 @@ void Manager::Poll(std::vector* ready, double timeout, IOSource* time // Ignore interrupts since we may catch one during shutdown and we don't want the // error to get printed. if ( errno != EINTR ) - zeek::reporter->InternalWarning("Error calling kevent: %s", strerror(errno)); + reporter->InternalWarning("Error calling kevent: %s", strerror(errno)); } else if ( ret == 0 ) { @@ -243,7 +243,7 @@ bool Manager::RegisterFd(int fd, IOSource* src) if ( ret != -1 ) { events.push_back({}); - DBG_LOG(zeek::DBG_MAINLOOP, "Registered fd %d from %s", fd, src->Tag()); + DBG_LOG(DBG_MAINLOOP, "Registered fd %d from %s", fd, src->Tag()); fd_map[fd] = src; Wakeup("RegisterFd"); @@ -251,7 +251,7 @@ bool Manager::RegisterFd(int fd, IOSource* src) } else { - zeek::reporter->Error("Failed to register fd %d from %s: %s", fd, src->Tag(), strerror(errno)); + reporter->Error("Failed to register fd %d from %s: %s", fd, src->Tag(), strerror(errno)); return false; } } @@ -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(zeek::DBG_MAINLOOP, "Unregistered fd %d from %s", fd, src->Tag()); + DBG_LOG(DBG_MAINLOOP, "Unregistered fd %d from %s", fd, src->Tag()); fd_map.erase(fd); @@ -273,7 +273,7 @@ bool Manager::UnregisterFd(int fd, IOSource* src) } else { - zeek::reporter->Error("Attempted to unregister an unknown file descriptor %d from %s", fd, src->Tag()); + reporter->Error("Attempted to unregister an unknown file descriptor %d from %s", fd, src->Tag()); return false; } } @@ -315,7 +315,7 @@ void Manager::Register(PktSrc* src) // little bit for those sources. if ( src->IsLive() ) poll_interval = 10; - else if ( zeek::run_state::pseudo_realtime ) + else if ( run_state::pseudo_realtime ) poll_interval = 1; Register(src, false); @@ -350,7 +350,7 @@ PktSrc* Manager::OpenPktSrc(const std::string& path, bool is_live) PktSrcComponent* component = nullptr; - std::list all_components = zeek::plugin_mgr->Components(); + std::list all_components = plugin_mgr->Components(); for ( const auto& c : all_components ) { if ( c->HandlesPrefix(prefix) && @@ -364,14 +364,14 @@ PktSrc* Manager::OpenPktSrc(const std::string& path, bool is_live) if ( ! component ) - zeek::reporter->FatalError("type of packet source '%s' not recognized, or mode not supported", prefix.c_str()); + reporter->FatalError("type of packet source '%s' not recognized, or mode not supported", prefix.c_str()); // Instantiate packet source. PktSrc* ps = (*component->Factory())(npath, is_live); assert(ps); - DBG_LOG(zeek::DBG_PKTIO, "Created packet source of type %s for %s", component->Name().c_str(), npath.c_str()); + DBG_LOG(DBG_PKTIO, "Created packet source of type %s for %s", component->Name().c_str(), npath.c_str()); Register(ps); return ps; @@ -388,7 +388,7 @@ PktDumper* Manager::OpenPktDumper(const std::string& path, bool append) PktDumperComponent* component = nullptr; - std::list all_components = zeek::plugin_mgr->Components(); + std::list all_components = plugin_mgr->Components(); for ( const auto& c : all_components ) { if ( c->HandlesPrefix(prefix) ) @@ -399,7 +399,7 @@ PktDumper* Manager::OpenPktDumper(const std::string& path, bool append) } if ( ! component ) - zeek::reporter->FatalError("type of packet dumper '%s' not recognized", prefix.c_str()); + reporter->FatalError("type of packet dumper '%s' not recognized", prefix.c_str()); // Instantiate packet dumper. @@ -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(zeek::DBG_PKTIO, "Created packer dumper of type %s for %s", component->Name().c_str(), npath.c_str()); + DBG_LOG(DBG_PKTIO, "Created packer dumper of type %s for %s", component->Name().c_str(), npath.c_str()); pd->Init(); pkt_dumpers.push_back(pd); diff --git a/src/iosource/Packet.cc b/src/iosource/Packet.cc index 6d0d1349f9..c7bbb87412 100644 --- a/src/iosource/Packet.cc +++ b/src/iosource/Packet.cc @@ -68,9 +68,9 @@ void Packet::Init(int arg_link_type, pkt_timeval *arg_ts, uint32_t arg_caplen, ProcessLayer2(); } -const zeek::IP_Hdr Packet::IP() const +const IP_Hdr Packet::IP() const { - return zeek::IP_Hdr((struct ip *) (data + hdr_size), false); + return IP_Hdr((struct ip *) (data + hdr_size), false); } void Packet::Weird(const char* name) @@ -593,12 +593,12 @@ void Packet::ProcessLayer2() hdr_size = (pdata - data); } -zeek::RecordValPtr Packet::ToRawPktHdrVal() const +RecordValPtr Packet::ToRawPktHdrVal() const { - static auto raw_pkt_hdr_type = zeek::id::find_type("raw_pkt_hdr"); - static auto l2_hdr_type = zeek::id::find_type("l2_hdr"); - auto pkt_hdr = zeek::make_intrusive(raw_pkt_hdr_type); - auto l2_hdr = zeek::make_intrusive(l2_hdr_type); + static auto raw_pkt_hdr_type = id::find_type("raw_pkt_hdr"); + static auto l2_hdr_type = id::find_type("l2_hdr"); + auto pkt_hdr = make_intrusive(raw_pkt_hdr_type); + auto l2_hdr = make_intrusive(l2_hdr_type); bool is_ethernet = link_type == DLT_EN10MB; @@ -628,41 +628,41 @@ zeek::RecordValPtr Packet::ToRawPktHdrVal() const { // Ethernet header layout is: // dst[6bytes] src[6bytes] ethertype[2bytes]... - l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_ETHERNET)); + l2_hdr->Assign(0, BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_ETHERNET)); l2_hdr->Assign(3, FmtEUI48(data + 6)); // src l2_hdr->Assign(4, FmtEUI48(data)); // dst if ( vlan ) - l2_hdr->Assign(5, zeek::val_mgr->Count(vlan)); + l2_hdr->Assign(5, val_mgr->Count(vlan)); if ( inner_vlan ) - l2_hdr->Assign(6, zeek::val_mgr->Count(inner_vlan)); + l2_hdr->Assign(6, val_mgr->Count(inner_vlan)); - l2_hdr->Assign(7, zeek::val_mgr->Count(eth_type)); + l2_hdr->Assign(7, val_mgr->Count(eth_type)); if ( eth_type == ETHERTYPE_ARP || eth_type == ETHERTYPE_REVARP ) // We also identify ARP for L3 over ethernet l3 = BifEnum::L3_ARP; } else - l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_UNKNOWN)); + l2_hdr->Assign(0, BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_UNKNOWN)); - l2_hdr->Assign(1, zeek::val_mgr->Count(len)); - l2_hdr->Assign(2, zeek::val_mgr->Count(cap_len)); + l2_hdr->Assign(1, val_mgr->Count(len)); + l2_hdr->Assign(2, val_mgr->Count(cap_len)); - l2_hdr->Assign(8, zeek::BifType::Enum::layer3_proto->GetEnumVal(l3)); + l2_hdr->Assign(8, BifType::Enum::layer3_proto->GetEnumVal(l3)); pkt_hdr->Assign(0, std::move(l2_hdr)); if ( l3_proto == L3_IPV4 ) { - zeek::IP_Hdr ip_hdr((const struct ip*)(data + hdr_size), false); + IP_Hdr ip_hdr((const struct ip*)(data + hdr_size), false); return ip_hdr.ToPktHdrVal(std::move(pkt_hdr), 1); } else if ( l3_proto == L3_IPV6 ) { - zeek::IP_Hdr ip6_hdr((const struct ip6_hdr*)(data + hdr_size), false, cap_len); + IP_Hdr ip6_hdr((const struct ip6_hdr*)(data + hdr_size), false, cap_len); return ip6_hdr.ToPktHdrVal(std::move(pkt_hdr), 1); } @@ -670,22 +670,22 @@ zeek::RecordValPtr Packet::ToRawPktHdrVal() const return pkt_hdr; } -zeek::RecordVal* Packet::BuildPktHdrVal() const +RecordVal* Packet::BuildPktHdrVal() const { return ToRawPktHdrVal().release(); } -zeek::ValPtr Packet::FmtEUI48(const u_char* mac) const +ValPtr Packet::FmtEUI48(const u_char* mac) const { char buf[20]; snprintf(buf, sizeof buf, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); - return zeek::make_intrusive(buf); + return make_intrusive(buf); } void Packet::Describe(ODesc* d) const { - const zeek::IP_Hdr ip = IP(); + const IP_Hdr ip = IP(); d->Add(ip.SrcAddr()); d->Add("->"); d->Add(ip.DstAddr()); diff --git a/src/iosource/Packet.h b/src/iosource/Packet.h index f0c30f9b08..5ac6f1f876 100644 --- a/src/iosource/Packet.h +++ b/src/iosource/Packet.h @@ -22,8 +22,8 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(IP_Hdr, zeek); namespace zeek { template class IntrusivePtr; -using ValPtr = zeek::IntrusivePtr; -using RecordValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; +using RecordValPtr = IntrusivePtr; /** * The Layer 3 type of a packet, as determined by the parsing code in Packet. @@ -129,16 +129,16 @@ public: * Interprets the Layer 3 of the packet as IP and returns a * correspondign object. */ - const zeek::IP_Hdr IP() const; + const IP_Hdr IP() const; /** * Returns a \c raw_pkt_hdr RecordVal, which includes layer 2 and - * also everything in zeek::IP_Hdr (i.e., IP4/6 + TCP/UDP/ICMP). + * also everything in IP_Hdr (i.e., IP4/6 + TCP/UDP/ICMP). */ - zeek::RecordValPtr ToRawPktHdrVal() const; + RecordValPtr ToRawPktHdrVal() const; [[deprecated("Remove in v4.1. Use ToRawPktHdrval() instead.")]] - zeek::RecordVal* BuildPktHdrVal() const; + RecordVal* BuildPktHdrVal() const; /** * Static method returning the link-layer header size for a given @@ -232,7 +232,7 @@ private: void Weird(const char* name); // Renders an MAC address into its ASCII representation. - zeek::ValPtr FmtEUI48(const u_char* mac) const; + ValPtr FmtEUI48(const u_char* mac) const; // True if we need to delete associated packet memory upon // destruction. diff --git a/src/iosource/PktDumper.cc b/src/iosource/PktDumper.cc index 0ca6511df9..87e4c6cae7 100644 --- a/src/iosource/PktDumper.cc +++ b/src/iosource/PktDumper.cc @@ -62,13 +62,13 @@ void PktDumper::Opened(const Properties& arg_props) { is_open = true; props = arg_props; - DBG_LOG(zeek::DBG_PKTIO, "Opened dumper %s", props.path.c_str()); + DBG_LOG(DBG_PKTIO, "Opened dumper %s", props.path.c_str()); } void PktDumper::Closed() { is_open = false; - DBG_LOG(zeek::DBG_PKTIO, "Closed dumper %s", props.path.c_str()); + DBG_LOG(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(zeek::DBG_PKTIO, "Error with dumper %s: %s", + DBG_LOG(DBG_PKTIO, "Error with dumper %s: %s", IsOpen() ? props.path.c_str() : "", msg.c_str()); } diff --git a/src/iosource/PktDumper.h b/src/iosource/PktDumper.h index e105bc0039..c279a704f0 100644 --- a/src/iosource/PktDumper.h +++ b/src/iosource/PktDumper.h @@ -85,7 +85,7 @@ public: * @return True if succesful, false otherwise (in which case \a * Error() must have been called.) */ - virtual bool Dump(const zeek::Packet* pkt) = 0; + virtual bool Dump(const Packet* pkt) = 0; protected: friend class Manager; diff --git a/src/iosource/PktSrc.cc b/src/iosource/PktSrc.cc index f551445aac..c20e29d35c 100644 --- a/src/iosource/PktSrc.cc +++ b/src/iosource/PktSrc.cc @@ -82,15 +82,15 @@ double PktSrc::CurrentPacketTimestamp() double PktSrc::CurrentPacketWallClock() { // We stop time when we are suspended. - if ( zeek::run_state::is_processing_suspended() ) - current_wallclock = zeek::util::current_time(true); + if ( run_state::is_processing_suspended() ) + current_wallclock = util::current_time(true); return current_wallclock; } void PktSrc::Opened(const Properties& arg_props) { - if ( zeek::Packet::GetLinkHeaderSize(arg_props.link_type) < 0 ) + if ( Packet::GetLinkHeaderSize(arg_props.link_type) < 0 ) { char buf[512]; snprintf(buf, sizeof(buf), @@ -112,7 +112,7 @@ void PktSrc::Opened(const Properties& arg_props) if ( props.is_live ) { - Info(zeek::util::fmt("listening on %s\n", props.path.c_str())); + Info(util::fmt("listening on %s\n", props.path.c_str())); // We only register the file descriptor if we're in live // mode because libpcap's file descriptor for trace files @@ -120,10 +120,10 @@ void PktSrc::Opened(const Properties& arg_props) // data to read. if ( props.selectable_fd != -1 ) if ( ! iosource_mgr->RegisterFd(props.selectable_fd, this) ) - zeek::reporter->FatalError("Failed to register pktsrc fd with iosource_mgr"); + reporter->FatalError("Failed to register pktsrc fd with iosource_mgr"); } - DBG_LOG(zeek::DBG_PKTIO, "Opened source %s", props.path.c_str()); + DBG_LOG(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(zeek::DBG_PKTIO, "Closed source %s", props.path.c_str()); + DBG_LOG(DBG_PKTIO, "Closed source %s", props.path.c_str()); } void PktSrc::Error(const std::string& msg) @@ -141,29 +141,29 @@ 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(zeek::DBG_PKTIO, "Error with source %s: %s", + DBG_LOG(DBG_PKTIO, "Error with source %s: %s", IsOpen() ? props.path.c_str() : "", msg.c_str()); } void PktSrc::Info(const std::string& msg) { - zeek::reporter->Info("%s", msg.c_str()); + reporter->Info("%s", msg.c_str()); } -void PktSrc::Weird(const std::string& msg, const zeek::Packet* p) +void PktSrc::Weird(const std::string& msg, const Packet* p) { - zeek::sessions->Weird(msg.c_str(), p, nullptr); + sessions->Weird(msg.c_str(), p, nullptr); } void PktSrc::InternalError(const std::string& msg) { - zeek::reporter->InternalError("%s", msg.c_str()); + reporter->InternalError("%s", msg.c_str()); } void PktSrc::ContinueAfterSuspend() { - current_wallclock = zeek::util::current_time(true); + current_wallclock = util::current_time(true); } double PktSrc::CheckPseudoTime() @@ -175,9 +175,9 @@ double PktSrc::CheckPseudoTime() return 0; double pseudo_time = current_packet.time - first_timestamp; - double ct = (zeek::util::current_time(true) - first_wallclock) * zeek::run_state::pseudo_realtime; + double ct = (util::current_time(true) - first_wallclock) * run_state::pseudo_realtime; - return pseudo_time <= ct ? zeek::run_state::zeek_start_time + pseudo_time : 0; + return pseudo_time <= ct ? run_state::zeek_start_time + pseudo_time : 0; } void PktSrc::InitSource() @@ -201,16 +201,16 @@ void PktSrc::Process() if ( current_packet.Layer2Valid() ) { - if ( zeek::run_state::pseudo_realtime ) + if ( run_state::pseudo_realtime ) { current_pseudo = CheckPseudoTime(); - zeek::run_state::detail::dispatch_packet(current_pseudo, ¤t_packet, this); + run_state::detail::dispatch_packet(current_pseudo, ¤t_packet, this); if ( ! first_wallclock ) - first_wallclock = zeek::util::current_time(true); + first_wallclock = util::current_time(true); } else - zeek::run_state::detail::dispatch_packet(current_packet.time, ¤t_packet, this); + run_state::detail::dispatch_packet(current_packet.time, ¤t_packet, this); } have_packet = false; @@ -231,11 +231,11 @@ bool PktSrc::ExtractNextPacketInternal() // Don't return any packets if processing is suspended (except for the // very first packet which we need to set up times). - if ( zeek::run_state::is_processing_suspended() && first_timestamp ) + if ( run_state::is_processing_suspended() && first_timestamp ) return false; - if ( zeek::run_state::pseudo_realtime ) - current_wallclock = zeek::util::current_time(true); + if ( run_state::pseudo_realtime ) + current_wallclock = util::current_time(true); if ( ExtractNextPacket(¤t_packet) ) { @@ -252,7 +252,7 @@ bool PktSrc::ExtractNextPacketInternal() return true; } - if ( zeek::run_state::pseudo_realtime && ! IsOpen() ) + if ( run_state::pseudo_realtime && ! IsOpen() ) { if ( broker_mgr->Active() ) iosource_mgr->Terminate(); @@ -269,11 +269,11 @@ bool PktSrc::PrecompileBPFFilter(int index, const std::string& filter) char errbuf[PCAP_ERRBUF_SIZE]; // Compile filter. - auto* code = new zeek::iosource::detail::BPF_Program(); + auto* code = new detail::BPF_Program(); - if ( ! code->Compile(zeek::BifConst::Pcap::snaplen, LinkType(), filter.c_str(), Netmask(), errbuf, sizeof(errbuf)) ) + if ( ! code->Compile(BifConst::Pcap::snaplen, LinkType(), filter.c_str(), Netmask(), errbuf, sizeof(errbuf)) ) { - std::string msg = zeek::util::fmt("cannot compile BPF filter \"%s\"", filter.c_str()); + std::string msg = util::fmt("cannot compile BPF filter \"%s\"", filter.c_str()); if ( *errbuf ) msg += ": " + std::string(errbuf); @@ -296,7 +296,7 @@ bool PktSrc::PrecompileBPFFilter(int index, const std::string& filter) return true; } -zeek::iosource::detail::BPF_Program* PktSrc::GetBPFFilter(int index) +detail::BPF_Program* PktSrc::GetBPFFilter(int index) { if ( index < 0 ) return nullptr; @@ -306,11 +306,11 @@ zeek::iosource::detail::BPF_Program* PktSrc::GetBPFFilter(int index) bool PktSrc::ApplyBPFFilter(int index, const struct pcap_pkthdr *hdr, const u_char *pkt) { - zeek::iosource::detail::BPF_Program* code = GetBPFFilter(index); + detail::BPF_Program* code = GetBPFFilter(index); if ( ! code ) { - Error(zeek::util::fmt("BPF filter %d not compiled", index)); + Error(util::fmt("BPF filter %d not compiled", index)); Close(); return false; } @@ -321,7 +321,7 @@ bool PktSrc::ApplyBPFFilter(int index, const struct pcap_pkthdr *hdr, const u_ch return pcap_offline_filter(code->GetProgram(), hdr, pkt); } -bool PktSrc::GetCurrentPacket(const zeek::Packet** pkt) +bool PktSrc::GetCurrentPacket(const Packet** pkt) { if ( ! have_packet ) return false; @@ -344,16 +344,16 @@ double PktSrc::GetNextTimeout() // but we're not in pseudo-realtime mode, let the loop just spin as fast as it can. If we're // in pseudo-realtime mode, find the next time that a packet is ready and have poll block until // then. - if ( IsLive() || zeek::run_state::is_processing_suspended() ) + if ( IsLive() || run_state::is_processing_suspended() ) return -1; - else if ( ! zeek::run_state::pseudo_realtime ) + else if ( ! run_state::pseudo_realtime ) return 0; if ( ! have_packet ) ExtractNextPacketInternal(); double pseudo_time = current_packet.time - first_timestamp; - double ct = (zeek::util::current_time(true) - first_wallclock) * zeek::run_state::pseudo_realtime; + double ct = (util::current_time(true) - first_wallclock) * run_state::pseudo_realtime; return std::max(0.0, pseudo_time - ct); } diff --git a/src/iosource/PktSrc.h b/src/iosource/PktSrc.h index 9b97bad3bc..66708da6b1 100644 --- a/src/iosource/PktSrc.h +++ b/src/iosource/PktSrc.h @@ -136,7 +136,7 @@ public: * @return The BPF filter associated, or null if none has been * (successfully) compiled. */ - zeek::iosource::detail::BPF_Program* GetBPFFilter(int index); + detail::BPF_Program* GetBPFFilter(int index); /** * Applies a precompiled BPF filter to a packet. This will close the @@ -163,7 +163,7 @@ public: * * @return True if the current packet is available, or false if not. */ - bool GetCurrentPacket(const zeek::Packet** hdr); + bool GetCurrentPacket(const Packet** hdr); // PacketSource interace for derived classes to override. @@ -297,7 +297,7 @@ protected: * * @param pkt The packet associated with the weird, or null if none. */ - void Weird(const std::string& msg, const zeek::Packet* pkt); + void Weird(const std::string& msg, const Packet* pkt); /** * Can be called from derived classes to flag an internal error, @@ -340,7 +340,7 @@ protected: * if not packet is available or an error occured (which must be * flageed via Error()). */ - virtual bool ExtractNextPacket(zeek::Packet* pkt) = 0; + virtual bool ExtractNextPacket(Packet* pkt) = 0; /** * Signals that the data of previously extracted packet will no @@ -365,10 +365,10 @@ private: Properties props; bool have_packet; - zeek::Packet current_packet; + Packet current_packet; // For BPF filtering support. - std::vector filters; + std::vector filters; // Only set in pseudo-realtime mode. double first_timestamp; diff --git a/src/iosource/pcap/Dumper.cc b/src/iosource/pcap/Dumper.cc index f558c67840..78e3f97cf8 100644 --- a/src/iosource/pcap/Dumper.cc +++ b/src/iosource/pcap/Dumper.cc @@ -27,7 +27,7 @@ void PcapDumper::Open() { int linktype = -1; - pd = pcap_open_dead(DLT_EN10MB, zeek::BifConst::Pcap::snaplen); + pd = pcap_open_dead(DLT_EN10MB, BifConst::Pcap::snaplen); if ( ! pd ) { @@ -51,7 +51,7 @@ void PcapDumper::Open() if ( exists < 0 && errno != ENOENT ) { - Error(zeek::util::fmt("can't stat file %s: %s", props.path.c_str(), strerror(errno))); + Error(util::fmt("can't stat file %s: %s", props.path.c_str(), strerror(errno))); return; } } @@ -76,13 +76,13 @@ void PcapDumper::Open() dumper = (pcap_dumper_t*) fopen(props.path.c_str(), "a"); if ( ! dumper ) { - Error(zeek::util::fmt("can't open dump %s: %s", props.path.c_str(), strerror(errno))); + Error(util::fmt("can't open dump %s: %s", props.path.c_str(), strerror(errno))); return; } } - props.open_time = zeek::run_state::network_time; - props.hdr_size = zeek::Packet::GetLinkHeaderSize(pcap_datalink(pd)); + props.open_time = run_state::network_time; + props.hdr_size = Packet::GetLinkHeaderSize(pcap_datalink(pd)); Opened(props); } @@ -99,7 +99,7 @@ void PcapDumper::Close() Closed(); } -bool PcapDumper::Dump(const zeek::Packet* pkt) +bool PcapDumper::Dump(const Packet* pkt) { if ( ! dumper ) return false; diff --git a/src/iosource/pcap/Dumper.h b/src/iosource/pcap/Dumper.h index 0c4c122591..96e2c10271 100644 --- a/src/iosource/pcap/Dumper.h +++ b/src/iosource/pcap/Dumper.h @@ -21,7 +21,7 @@ protected: // PktDumper interface. void Open() override; void Close() override; - bool Dump(const zeek::Packet* pkt) override; + bool Dump(const Packet* pkt) override; private: Properties props; diff --git a/src/iosource/pcap/Plugin.cc b/src/iosource/pcap/Plugin.cc index c23a77a137..abc0e2708b 100644 --- a/src/iosource/pcap/Plugin.cc +++ b/src/iosource/pcap/Plugin.cc @@ -7,17 +7,17 @@ namespace zeek::plugin::detail::Zeek_Pcap { -class Plugin : public zeek::plugin::Plugin { +class Plugin : public plugin::Plugin { public: - zeek::plugin::Configuration Configure() override + plugin::Configuration Configure() override { - AddComponent(new zeek::iosource::PktSrcComponent( - "PcapReader", "pcap", zeek::iosource::PktSrcComponent::BOTH, - zeek::iosource::pcap::PcapSource::Instantiate)); - AddComponent(new zeek::iosource::PktDumperComponent( - "PcapWriter", "pcap", zeek::iosource::pcap::PcapDumper::Instantiate)); + AddComponent(new iosource::PktSrcComponent( + "PcapReader", "pcap", iosource::PktSrcComponent::BOTH, + iosource::pcap::PcapSource::Instantiate)); + AddComponent(new iosource::PktDumperComponent( + "PcapWriter", "pcap", iosource::pcap::PcapDumper::Instantiate)); - zeek::plugin::Configuration config; + plugin::Configuration config; config.name = "Zeek::Pcap"; config.description = "Packet acquisition via libpcap"; return config; diff --git a/src/iosource/pcap/Source.cc b/src/iosource/pcap/Source.cc index 2aa522e751..769b12ecdb 100644 --- a/src/iosource/pcap/Source.cc +++ b/src/iosource/pcap/Source.cc @@ -47,7 +47,7 @@ void PcapSource::Close() Closed(); if ( Pcap::file_done ) - zeek::event_mgr.Enqueue(Pcap::file_done, zeek::make_intrusive(props.path)); + event_mgr.Enqueue(Pcap::file_done, make_intrusive(props.path)); } void PcapSource::OpenLive() @@ -61,7 +61,7 @@ void PcapSource::OpenLive() if ( pcap_findalldevs(&devs, errbuf) < 0 ) { - Error(zeek::util::fmt("pcap_findalldevs: %s", errbuf)); + Error(util::fmt("pcap_findalldevs: %s", errbuf)); return; } @@ -110,7 +110,7 @@ void PcapSource::OpenLive() return; } - if ( pcap_set_snaplen(pd, zeek::BifConst::Pcap::snaplen) ) + if ( pcap_set_snaplen(pd, BifConst::Pcap::snaplen) ) { PcapError("pcap_set_snaplen"); return; @@ -136,7 +136,7 @@ void PcapSource::OpenLive() return; } - if ( pcap_set_buffer_size(pd, zeek::BifConst::Pcap::bufsize * 1024 * 1024) ) + if ( pcap_set_buffer_size(pd, BifConst::Pcap::bufsize * 1024 * 1024) ) { PcapError("pcap_set_buffer_size"); return; @@ -157,7 +157,7 @@ void PcapSource::OpenLive() #endif #ifdef HAVE_PCAP_INT_H - Info(zeek::util::fmt("pcap bufsize = %d\n", ((struct pcap *) pd)->bufsize)); + Info(util::fmt("pcap bufsize = %d\n", ((struct pcap *) pd)->bufsize)); #endif props.selectable_fd = pcap_get_selectable_fd(pd); @@ -191,7 +191,7 @@ void PcapSource::OpenOffline() Opened(props); } -bool PcapSource::ExtractNextPacket(zeek::Packet* pkt) +bool PcapSource::ExtractNextPacket(Packet* pkt) { if ( ! pd ) return false; @@ -210,11 +210,11 @@ bool PcapSource::ExtractNextPacket(zeek::Packet* pkt) case PCAP_ERROR: // -1 // Error occurred while reading the packet. if ( props.is_live ) - zeek::reporter->Error("failed to read a packet from %s: %s", - props.path.data(), pcap_geterr(pd)); + reporter->Error("failed to read a packet from %s: %s", + props.path.data(), pcap_geterr(pd)); else - zeek::reporter->FatalError("failed to read a packet from %s: %s", - props.path.data(), pcap_geterr(pd)); + reporter->FatalError("failed to read a packet from %s: %s", + props.path.data(), pcap_geterr(pd)); return false; case 0: // Read from live interface timed out (ok). @@ -223,7 +223,7 @@ bool PcapSource::ExtractNextPacket(zeek::Packet* pkt) // Read a packet without problem. break; default: - zeek::reporter->InternalError("unhandled pcap_next_ex return value: %d", res); + reporter->InternalError("unhandled pcap_next_ex return value: %d", res); return false; } @@ -258,7 +258,7 @@ bool PcapSource::SetFilter(int index) char errbuf[PCAP_ERRBUF_SIZE]; - zeek::iosource::detail::BPF_Program* code = GetBPFFilter(index); + iosource::detail::BPF_Program* code = GetBPFFilter(index); if ( ! code ) { @@ -328,12 +328,12 @@ void PcapSource::PcapError(const char* where) std::string location; if ( where ) - location = zeek::util::fmt(" (%s)", where); + location = util::fmt(" (%s)", where); if ( pd ) - Error(zeek::util::fmt("pcap_error: %s%s", pcap_geterr(pd), location.c_str())); + Error(util::fmt("pcap_error: %s%s", pcap_geterr(pd), location.c_str())); else - Error(zeek::util::fmt("pcap_error: not open%s", location.c_str())); + Error(util::fmt("pcap_error: not open%s", location.c_str())); Close(); } diff --git a/src/iosource/pcap/Source.h b/src/iosource/pcap/Source.h index 5309bd36dc..e3b9944b42 100644 --- a/src/iosource/pcap/Source.h +++ b/src/iosource/pcap/Source.h @@ -12,7 +12,7 @@ extern "C" { namespace zeek::iosource::pcap { -class PcapSource : public zeek::iosource::PktSrc { +class PcapSource : public PktSrc { public: PcapSource(const std::string& path, bool is_live); ~PcapSource() override; @@ -23,7 +23,7 @@ protected: // PktSrc interface. void Open() override; void Close() override; - bool ExtractNextPacket(zeek::Packet* pkt) override; + bool ExtractNextPacket(Packet* pkt) override; void DoneWithPacket() override; bool PrecompileFilter(int index, const std::string& filter) override; bool SetFilter(int index) override; diff --git a/src/legacy-netvar-init.cc b/src/legacy-netvar-init.cc index fed53a1f1e..e83e452e56 100644 --- a/src/legacy-netvar-init.cc +++ b/src/legacy-netvar-init.cc @@ -9,75 +9,75 @@ namespace zeek::detail { // Compiled separately to avoid deprecation warnings at the assignment sites. void zeek_legacy_netvar_init() { - ::conn_id = zeek::id::conn_id.get(); - ::endpoint = zeek::id::endpoint.get(); - ::connection_type = zeek::id::connection.get(); - ::fa_file_type = zeek::id::fa_file.get(); - ::fa_metadata_type = zeek::id::fa_metadata.get(); - ::icmp_conn = zeek::id::find_type("icmp_conn")->AsRecordType(); - ::icmp_context = zeek::id::find_type("icmp_context")->AsRecordType(); - ::signature_state = zeek::id::find_type("signature_state")->AsRecordType(); - ::SYN_packet = zeek::id::find_type("SYN_packet")->AsRecordType(); - ::pcap_packet = zeek::id::find_type("pcap_packet")->AsRecordType(); - ::raw_pkt_hdr_type = zeek::id::find_type("raw_pkt_hdr")->AsRecordType(); - ::l2_hdr_type = zeek::id::find_type("l2_hdr")->AsRecordType(); - ::transport_proto = zeek::id::transport_proto.get(); - ::string_set = zeek::id::string_set.get(); - ::string_array = zeek::id::string_array.get(); - ::count_set = zeek::id::count_set.get(); - ::string_vec = zeek::id::string_vec.get(); - ::index_vec = zeek::id::index_vec.get(); - ::mime_matches = zeek::id::find_type("mime_matches")->AsVectorType(); - ::mime_match = zeek::id::find_type("mime_match")->AsRecordType(); - ::socks_address = zeek::id::find_type("SOCKS::Address")->AsRecordType(); - ::mime_header_rec = zeek::id::find_type("mime_header_rec")->AsRecordType(); - ::mime_header_list = zeek::id::find_type("mime_header_list")->AsTableType(); - ::http_stats_rec = zeek::id::find_type("http_stats_rec")->AsRecordType(); - ::http_message_stat = zeek::id::find_type("http_message_stat")->AsRecordType(); - ::pm_mapping = zeek::id::find_type("pm_mapping")->AsRecordType(); - ::pm_mappings = zeek::id::find_type("pm_mappings")->AsTableType(); - ::pm_port_request = zeek::id::find_type("pm_port_request")->AsRecordType(); - ::pm_callit_request = zeek::id::find_type("pm_callit_request")->AsRecordType(); - ::geo_location = zeek::id::find_type("geo_location")->AsRecordType(); - ::entropy_test_result = zeek::id::find_type("entropy_test_result")->AsRecordType(); - ::dns_msg = zeek::id::find_type("dns_msg")->AsRecordType(); - ::dns_answer = zeek::id::find_type("dns_answer")->AsRecordType(); - ::dns_soa = zeek::id::find_type("dns_soa")->AsRecordType(); - ::dns_edns_additional = zeek::id::find_type("dns_edns_additional")->AsRecordType(); - ::dns_edns_ecs = zeek::id::find_type("dns_edns_ecs")->AsRecordType(); - ::dns_tsig_additional = zeek::id::find_type("dns_tsig_additional")->AsRecordType(); - ::dns_rrsig_rr = zeek::id::find_type("dns_rrsig_rr")->AsRecordType(); - ::dns_dnskey_rr = zeek::id::find_type("dns_dnskey_rr")->AsRecordType(); - ::dns_nsec3_rr = zeek::id::find_type("dns_nsec3_rr")->AsRecordType(); - ::dns_ds_rr = zeek::id::find_type("dns_ds_rr")->AsRecordType(); - ::rotate_info = zeek::id::find_type("rotate_info")->AsRecordType(); - ::irc_join_list = zeek::id::find_type("irc_join_list")->AsTableType(); - ::irc_join_info = zeek::id::find_type("irc_join_info")->AsRecordType(); - ::script_id = zeek::id::find_type("script_id")->AsRecordType(); - ::id_table = zeek::id::find_type("id_table")->AsTableType(); - ::record_field = zeek::id::find_type("record_field")->AsRecordType(); - ::record_field_table = zeek::id::find_type("record_field_table")->AsTableType(); - ::call_argument = zeek::id::find_type("call_argument")->AsRecordType(); - ::call_argument_vector = zeek::id::find_type("call_argument_vector")->AsVectorType(); + ::conn_id = id::conn_id.get(); + ::endpoint = id::endpoint.get(); + ::connection_type = id::connection.get(); + ::fa_file_type = id::fa_file.get(); + ::fa_metadata_type = id::fa_metadata.get(); + ::icmp_conn = id::find_type("icmp_conn")->AsRecordType(); + ::icmp_context = id::find_type("icmp_context")->AsRecordType(); + ::signature_state = id::find_type("signature_state")->AsRecordType(); + ::SYN_packet = id::find_type("SYN_packet")->AsRecordType(); + ::pcap_packet = id::find_type("pcap_packet")->AsRecordType(); + ::raw_pkt_hdr_type = id::find_type("raw_pkt_hdr")->AsRecordType(); + ::l2_hdr_type = id::find_type("l2_hdr")->AsRecordType(); + ::transport_proto = id::transport_proto.get(); + ::string_set = id::string_set.get(); + ::string_array = id::string_array.get(); + ::count_set = id::count_set.get(); + ::string_vec = id::string_vec.get(); + ::index_vec = id::index_vec.get(); + ::mime_matches = id::find_type("mime_matches")->AsVectorType(); + ::mime_match = id::find_type("mime_match")->AsRecordType(); + ::socks_address = id::find_type("SOCKS::Address")->AsRecordType(); + ::mime_header_rec = id::find_type("mime_header_rec")->AsRecordType(); + ::mime_header_list = id::find_type("mime_header_list")->AsTableType(); + ::http_stats_rec = id::find_type("http_stats_rec")->AsRecordType(); + ::http_message_stat = id::find_type("http_message_stat")->AsRecordType(); + ::pm_mapping = id::find_type("pm_mapping")->AsRecordType(); + ::pm_mappings = id::find_type("pm_mappings")->AsTableType(); + ::pm_port_request = id::find_type("pm_port_request")->AsRecordType(); + ::pm_callit_request = id::find_type("pm_callit_request")->AsRecordType(); + ::geo_location = id::find_type("geo_location")->AsRecordType(); + ::entropy_test_result = id::find_type("entropy_test_result")->AsRecordType(); + ::dns_msg = id::find_type("dns_msg")->AsRecordType(); + ::dns_answer = id::find_type("dns_answer")->AsRecordType(); + ::dns_soa = id::find_type("dns_soa")->AsRecordType(); + ::dns_edns_additional = id::find_type("dns_edns_additional")->AsRecordType(); + ::dns_edns_ecs = id::find_type("dns_edns_ecs")->AsRecordType(); + ::dns_tsig_additional = id::find_type("dns_tsig_additional")->AsRecordType(); + ::dns_rrsig_rr = id::find_type("dns_rrsig_rr")->AsRecordType(); + ::dns_dnskey_rr = id::find_type("dns_dnskey_rr")->AsRecordType(); + ::dns_nsec3_rr = id::find_type("dns_nsec3_rr")->AsRecordType(); + ::dns_ds_rr = id::find_type("dns_ds_rr")->AsRecordType(); + ::rotate_info = id::find_type("rotate_info")->AsRecordType(); + ::irc_join_list = id::find_type("irc_join_list")->AsTableType(); + ::irc_join_info = id::find_type("irc_join_info")->AsRecordType(); + ::script_id = id::find_type("script_id")->AsRecordType(); + ::id_table = id::find_type("id_table")->AsTableType(); + ::record_field = id::find_type("record_field")->AsRecordType(); + ::record_field_table = id::find_type("record_field_table")->AsTableType(); + ::call_argument = id::find_type("call_argument")->AsRecordType(); + ::call_argument_vector = id::find_type("call_argument_vector")->AsVectorType(); - ::log_rotate_base_time = zeek::id::find_val("log_rotate_base_time")->AsStringVal(); - ::pkt_profile_file = zeek::id::find_val("pkt_profile_file").get(); - ::likely_server_ports = zeek::id::find_val("likely_server_ports")->AsTableVal(); - ::tcp_content_delivery_ports_orig = zeek::id::find_val("tcp_content_delivery_ports_orig")->AsTableVal(); - ::tcp_content_delivery_ports_resp = zeek::id::find_val("tcp_content_delivery_ports_resp")->AsTableVal(); - ::stp_skip_src = zeek::id::find_val("stp_skip_src")->AsTableVal(); - ::dns_skip_auth = zeek::id::find_val("dns_skip_auth")->AsTableVal(); - ::dns_skip_addl = zeek::id::find_val("dns_skip_addl")->AsTableVal(); - ::udp_content_ports = zeek::id::find_val("udp_content_ports")->AsTableVal(); - ::udp_content_delivery_ports_orig = zeek::id::find_val("udp_content_delivery_ports_orig")->AsTableVal(); - ::udp_content_delivery_ports_resp = zeek::id::find_val("udp_content_delivery_ports_resp")->AsTableVal(); - ::profiling_file = zeek::id::find_val("profiling_file").get(); - ::global_hash_seed = zeek::id::find_val("global_hash_seed")->AsStringVal(); - ::tcp_reassembler_ports_orig = zeek::id::find_val("tcp_reassembler_ports_orig")->AsTableVal(); - ::tcp_reassembler_ports_resp = zeek::id::find_val("tcp_reassembler_ports_resp")->AsTableVal(); - ::peer_description = zeek::id::find_val("peer_description")->AsStringVal(); - ::trace_output_file = zeek::id::find_val("trace_output_file")->AsStringVal(); - ::cmd_line_bpf_filter = zeek::id::find_val("cmd_line_bpf_filter")->AsStringVal(); + ::log_rotate_base_time = id::find_val("log_rotate_base_time")->AsStringVal(); + ::pkt_profile_file = id::find_val("pkt_profile_file").get(); + ::likely_server_ports = id::find_val("likely_server_ports")->AsTableVal(); + ::tcp_content_delivery_ports_orig = id::find_val("tcp_content_delivery_ports_orig")->AsTableVal(); + ::tcp_content_delivery_ports_resp = id::find_val("tcp_content_delivery_ports_resp")->AsTableVal(); + ::stp_skip_src = id::find_val("stp_skip_src")->AsTableVal(); + ::dns_skip_auth = id::find_val("dns_skip_auth")->AsTableVal(); + ::dns_skip_addl = id::find_val("dns_skip_addl")->AsTableVal(); + ::udp_content_ports = id::find_val("udp_content_ports")->AsTableVal(); + ::udp_content_delivery_ports_orig = id::find_val("udp_content_delivery_ports_orig")->AsTableVal(); + ::udp_content_delivery_ports_resp = id::find_val("udp_content_delivery_ports_resp")->AsTableVal(); + ::profiling_file = id::find_val("profiling_file").get(); + ::global_hash_seed = id::find_val("global_hash_seed")->AsStringVal(); + ::tcp_reassembler_ports_orig = id::find_val("tcp_reassembler_ports_orig")->AsTableVal(); + ::tcp_reassembler_ports_resp = id::find_val("tcp_reassembler_ports_resp")->AsTableVal(); + ::peer_description = id::find_val("peer_description")->AsStringVal(); + ::trace_output_file = id::find_val("trace_output_file")->AsStringVal(); + ::cmd_line_bpf_filter = id::find_val("cmd_line_bpf_filter")->AsStringVal(); auto anon_id = global_scope()->Lookup("preserve_orig_addr"); diff --git a/src/logging/Component.cc b/src/logging/Component.cc index 644bc83c11..f700f18b64 100644 --- a/src/logging/Component.cc +++ b/src/logging/Component.cc @@ -8,7 +8,7 @@ namespace zeek::logging { Component::Component(const std::string& name, factory_callback arg_factory) - : zeek::plugin::Component(zeek::plugin::component::WRITER, name) + : plugin::Component(plugin::component::WRITER, name) { factory = arg_factory; } @@ -23,7 +23,7 @@ Component::~Component() { } -void Component::DoDescribe(zeek::ODesc* d) const +void Component::DoDescribe(ODesc* d) const { d->Add("Log::WRITER_"); d->Add(CanonicalName()); diff --git a/src/logging/Component.h b/src/logging/Component.h index d0cb52615f..0856a883d8 100644 --- a/src/logging/Component.h +++ b/src/logging/Component.h @@ -14,8 +14,8 @@ namespace zeek::logging { /** * Component description for plugins providing log writers. */ -class Component : public zeek::plugin::Component, - public zeek::plugin::TaggedComponent { +class Component : public plugin::Component, + public plugin::TaggedComponent { public: typedef WriterBackend* (*factory_callback)(WriterFrontend* frontend); @@ -54,7 +54,7 @@ protected: /** * Overriden from plugin::Component. */ - void DoDescribe(zeek::ODesc* d) const override; + void DoDescribe(ODesc* d) const override; private: factory_callback factory; diff --git a/src/logging/Manager.cc b/src/logging/Manager.cc index 4c41558393..9a6ac73ec9 100644 --- a/src/logging/Manager.cc +++ b/src/logging/Manager.cc @@ -32,24 +32,24 @@ using namespace std; namespace zeek::logging { struct Manager::Filter { - zeek::Val* fval; + Val* fval; string name; - zeek::EnumVal* id; - zeek::Func* pred; - zeek::Func* path_func; + EnumVal* id; + Func* pred; + Func* path_func; string path; - zeek::Val* path_val; - zeek::EnumVal* writer; - zeek::TableVal* config; - zeek::TableVal* field_name_map; + Val* path_val; + EnumVal* writer; + TableVal* config; + TableVal* field_name_map; string scope_sep; string ext_prefix; - zeek::Func* ext_func; + Func* ext_func; int num_ext_fields; bool local; bool remote; double interval; - zeek::Func* postprocessor; + Func* postprocessor; int num_fields; threading::Field** fields; @@ -63,11 +63,11 @@ struct Manager::Filter { }; struct Manager::WriterInfo { - zeek::EnumVal* type; + EnumVal* type; double open_time; - zeek::detail::Timer* rotation_timer; + detail::Timer* rotation_timer; double interval; - zeek::Func* postprocessor; + Func* postprocessor; WriterFrontend* writer; WriterBackend::WriterInfo* info; bool from_remote; @@ -76,11 +76,11 @@ struct Manager::WriterInfo { }; struct Manager::Stream { - zeek::EnumVal* id; + EnumVal* id; bool enabled; string name; - zeek::RecordType* columns; - zeek::EventHandlerPtr event; + RecordType* columns; + EventHandlerPtr event; list filters; typedef pair WriterPathPair; @@ -145,16 +145,16 @@ Manager::~Manager() void Manager::InitPostScript() { - rotation_format_func = zeek::id::find_func("Log::rotation_format_func"); + rotation_format_func = id::find_func("Log::rotation_format_func"); } -WriterBackend* Manager::CreateBackend(WriterFrontend* frontend, zeek::EnumVal* tag) +WriterBackend* Manager::CreateBackend(WriterFrontend* frontend, EnumVal* tag) { Component* c = Lookup(tag); if ( ! c ) { - zeek::reporter->Error("unknown writer type requested"); + reporter->Error("unknown writer type requested"); return nullptr; } @@ -164,7 +164,7 @@ WriterBackend* Manager::CreateBackend(WriterFrontend* frontend, zeek::EnumVal* t return backend; } -Manager::Stream* Manager::FindStream(zeek::EnumVal* id) +Manager::Stream* Manager::FindStream(EnumVal* id) { unsigned int idx = id->AsEnum(); @@ -234,15 +234,15 @@ void Manager::RemoveDisabledWriters(Stream* stream) stream->writers.erase(*j); } -bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval) +bool Manager::CreateStream(EnumVal* id, RecordVal* sval) { - if ( ! same_type(sval->GetType(), zeek::BifType::Record::Log::Stream, false) ) + if ( ! same_type(sval->GetType(), BifType::Record::Log::Stream, false) ) { - zeek::reporter->Error("sval argument not of right type"); + reporter->Error("sval argument not of right type"); return false; } - zeek::RecordType* columns = sval->GetField("columns") + RecordType* columns = sval->GetField("columns") ->AsType()->AsTypeType()->GetType()->AsRecordType(); bool log_attr_present = false; @@ -254,7 +254,7 @@ bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval) if ( ! threading::Value::IsCompatibleType(columns->GetFieldType(i).get()) ) { - zeek::reporter->Error("type of field '%s' is not support for logging output", + reporter->Error("type of field '%s' is not support for logging output", columns->FieldName(i)); return false; @@ -265,21 +265,21 @@ bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval) if ( ! log_attr_present ) { - zeek::reporter->Error("logged record type does not have any &log attributes"); + reporter->Error("logged record type does not have any &log attributes"); return false; } const auto& event_val = sval->GetField("ev"); - zeek::Func* event = event_val ? event_val->AsFunc() : nullptr; + Func* event = event_val ? event_val->AsFunc() : nullptr; if ( event ) { // Make sure the event is prototyped as expected. const auto& etype = event->GetType(); - if ( etype->Flavor() != zeek::FUNC_FLAVOR_EVENT ) + if ( etype->Flavor() != FUNC_FLAVOR_EVENT ) { - zeek::reporter->Error("stream event is a function, not an event"); + reporter->Error("stream event is a function, not an event"); return false; } @@ -287,13 +287,13 @@ bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval) if ( args.size() != 1 ) { - zeek::reporter->Error("stream event must take a single argument"); + reporter->Error("stream event must take a single argument"); return false; } if ( ! same_type(args[0], columns) ) { - zeek::reporter->Error("stream event's argument type does not match column record type"); + reporter->Error("stream event's argument type does not match column record type"); return false; } } @@ -315,18 +315,18 @@ bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval) streams[idx]->id = id->Ref()->AsEnumVal(); streams[idx]->enabled = true; streams[idx]->name = id->GetType()->AsEnumType()->Lookup(idx); - streams[idx]->event = event ? zeek::event_registry->Lookup(event->Name()) : nullptr; + streams[idx]->event = event ? event_registry->Lookup(event->Name()) : nullptr; streams[idx]->columns = columns->Ref()->AsRecordType(); - streams[idx]->enable_remote = zeek::id::find_val("Log::enable_remote_logging")->AsBool(); + streams[idx]->enable_remote = id::find_val("Log::enable_remote_logging")->AsBool(); - DBG_LOG(zeek::DBG_LOGGING, "Created new logging stream '%s', raising event %s", + DBG_LOG(DBG_LOGGING, "Created new logging stream '%s', raising event %s", streams[idx]->name.c_str(), event ? streams[idx]->event->Name() : ""); return true; } -bool Manager::RemoveStream(zeek::EnumVal* id) +bool Manager::RemoveStream(EnumVal* id) { unsigned int idx = id->AsEnum(); @@ -342,7 +342,7 @@ bool Manager::RemoveStream(zeek::EnumVal* id) { WriterInfo* winfo = i->second; - DBG_LOG(zeek::DBG_LOGGING, "Removed writer '%s' from stream '%s'", + DBG_LOG(DBG_LOGGING, "Removed writer '%s' from stream '%s'", winfo->writer->Name(), stream->name.c_str()); winfo->writer->Stop(); @@ -355,11 +355,11 @@ bool Manager::RemoveStream(zeek::EnumVal* id) delete stream; streams[idx] = nullptr; - DBG_LOG(zeek::DBG_LOGGING, "Removed logging stream '%s'", sname.c_str()); + DBG_LOG(DBG_LOGGING, "Removed logging stream '%s'", sname.c_str()); return true; } -bool Manager::EnableStream(zeek::EnumVal* id) +bool Manager::EnableStream(EnumVal* id) { Stream* stream = FindStream(id); @@ -371,11 +371,11 @@ bool Manager::EnableStream(zeek::EnumVal* id) stream->enabled = true; - DBG_LOG(zeek::DBG_LOGGING, "Reenabled logging stream '%s'", stream->name.c_str()); + DBG_LOG(DBG_LOGGING, "Reenabled logging stream '%s'", stream->name.c_str()); return true; } -bool Manager::DisableStream(zeek::EnumVal* id) +bool Manager::DisableStream(EnumVal* id) { Stream* stream = FindStream(id); @@ -387,13 +387,13 @@ bool Manager::DisableStream(zeek::EnumVal* id) stream->enabled = false; - DBG_LOG(zeek::DBG_LOGGING, "Disabled logging stream '%s'", stream->name.c_str()); + DBG_LOG(DBG_LOGGING, "Disabled logging stream '%s'", stream->name.c_str()); return true; } // Helper for recursive record field unrolling. -bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* rt, - zeek::TableVal* include, zeek::TableVal* exclude, +bool Manager::TraverseRecord(Stream* stream, Filter* filter, RecordType* rt, + TableVal* include, TableVal* exclude, const string& path, const list& indices) { // Only include extensions for the outer record. @@ -402,7 +402,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r int i = 0; for ( int j = 0; j < num_ext_fields + rt->NumFields(); ++j ) { - zeek::RecordType* rtype; + RecordType* rtype; // If this is an ext field, set the rtype appropriately if ( j < num_ext_fields ) { @@ -418,7 +418,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r const auto& t = rtype->GetFieldType(i); // Ignore if &log not specified. - if ( ! rtype->FieldDecl(i)->GetAttr(zeek::detail::ATTR_LOG) ) + if ( ! rtype->FieldDecl(i)->GetAttr(detail::ATTR_LOG) ) continue; list new_indices = indices; @@ -436,9 +436,9 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r if ( j < num_ext_fields ) new_path = filter->ext_prefix + new_path; - if ( t->InternalType() == zeek::TYPE_INTERNAL_OTHER ) + if ( t->InternalType() == TYPE_INTERNAL_OTHER ) { - if ( t->Tag() == zeek::TYPE_RECORD ) + if ( t->Tag() == TYPE_RECORD ) { // Recurse. if ( ! TraverseRecord(stream, filter, @@ -452,30 +452,30 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r continue; } - else if ( t->Tag() == zeek::TYPE_TABLE && + else if ( t->Tag() == TYPE_TABLE && t->AsTableType()->IsSet() ) { // That's ok, we handle it below. } - else if ( t->Tag() == zeek::TYPE_VECTOR ) + else if ( t->Tag() == TYPE_VECTOR ) { // That's ok, we handle it below. } - else if ( t->Tag() == zeek::TYPE_FILE ) + else if ( t->Tag() == TYPE_FILE ) { // That's ok, we handle it below. } - else if ( t->Tag() == zeek::TYPE_FUNC ) + else if ( t->Tag() == TYPE_FUNC ) { // That's ok, we handle it below. } else { - zeek::reporter->Error("unsupported field type for log column"); + reporter->Error("unsupported field type for log column"); return false; } } @@ -483,7 +483,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r // If include fields are specified, only include if explicitly listed. if ( include ) { - auto new_path_val = zeek::make_intrusive(new_path.c_str()); + auto new_path_val = make_intrusive(new_path.c_str()); bool result = (bool)include->FindOrDefault(new_path_val); if ( ! result ) @@ -493,7 +493,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r // If exclude fields are specified, do not only include if listed. if ( exclude ) { - auto new_path_val = zeek::make_intrusive(new_path.c_str()); + auto new_path_val = make_intrusive(new_path.c_str()); bool result = (bool)exclude->FindOrDefault(new_path_val); if ( result ) @@ -509,22 +509,22 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r if ( ! tmp ) { - zeek::reporter->Error("out of memory in add_filter"); + reporter->Error("out of memory in add_filter"); return false; } ++filter->num_fields; filter->fields = (threading::Field**) tmp; - zeek::TypeTag st = zeek::TYPE_VOID; + TypeTag st = TYPE_VOID; - if ( t->Tag() == zeek::TYPE_TABLE ) + if ( t->Tag() == TYPE_TABLE ) st = t->AsSetType()->GetIndices()->GetPureType()->Tag(); - else if ( t->Tag() == zeek::TYPE_VECTOR ) + else if ( t->Tag() == TYPE_VECTOR ) st = t->AsVectorType()->Yield()->Tag(); - bool optional = (bool)rtype->FieldDecl(i)->GetAttr(zeek::detail::ATTR_OPTIONAL); + bool optional = (bool)rtype->FieldDecl(i)->GetAttr(detail::ATTR_OPTIONAL); filter->fields[filter->num_fields - 1] = new threading::Field(new_path.c_str(), nullptr, t->Tag(), st, optional); } @@ -532,11 +532,11 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* r return true; } -bool Manager::AddFilter(zeek::EnumVal* id, zeek::RecordVal* fval) +bool Manager::AddFilter(EnumVal* id, RecordVal* fval) { - if ( ! same_type(fval->GetType(), zeek::BifType::Record::Log::Filter, false) ) + if ( ! same_type(fval->GetType(), BifType::Record::Log::Filter, false) ) { - zeek::reporter->Error("filter argument not of right type"); + reporter->Error("filter argument not of right type"); return false; } @@ -545,7 +545,7 @@ bool Manager::AddFilter(zeek::EnumVal* id, zeek::RecordVal* fval) return false; // Find the right writer type. - auto writer = fval->GetFieldOrDefault("writer"); + auto writer = fval->GetFieldOrDefault("writer"); // Create a new Filter instance. @@ -587,19 +587,19 @@ bool Manager::AddFilter(zeek::EnumVal* id, zeek::RecordVal* fval) filter->num_ext_fields = 0; if ( filter->ext_func ) { - if ( filter->ext_func->GetType()->Yield()->Tag() == zeek::TYPE_RECORD ) + if ( filter->ext_func->GetType()->Yield()->Tag() == TYPE_RECORD ) { filter->num_ext_fields = filter->ext_func->GetType()->Yield()->AsRecordType()->NumFields(); } - else if ( filter->ext_func->GetType()->Yield()->Tag() == zeek::TYPE_VOID ) + else if ( filter->ext_func->GetType()->Yield()->Tag() == TYPE_VOID ) { // This is a special marker for the default no-implementation // of the ext_func and we'll allow it to slide. } else { - zeek::reporter->Error("Return value of log_ext is not a record (got %s)", - zeek::type_name(filter->ext_func->GetType()->Yield()->Tag())); + reporter->Error("Return value of log_ext is not a record (got %s)", + type_name(filter->ext_func->GetType()->Yield()->Tag())); delete filter; return false; } @@ -639,34 +639,34 @@ bool Manager::AddFilter(zeek::EnumVal* id, zeek::RecordVal* fval) stream->filters.push_back(filter); #ifdef DEBUG - zeek::ODesc desc; + ODesc desc; writer->Describe(&desc); - DBG_LOG(zeek::DBG_LOGGING, "Created new filter '%s' for stream '%s'", + DBG_LOG(DBG_LOGGING, "Created new filter '%s' for stream '%s'", filter->name.c_str(), stream->name.c_str()); - 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")); + 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")); for ( int i = 0; i < filter->num_fields; i++ ) { threading::Field* field = filter->fields[i]; - DBG_LOG(zeek::DBG_LOGGING, " field %10s: %s", - field->name, zeek::type_name(field->type)); + DBG_LOG(DBG_LOGGING, " field %10s: %s", + field->name, type_name(field->type)); } #endif return true; } -bool Manager::RemoveFilter(zeek::EnumVal* id, zeek::StringVal* name) +bool Manager::RemoveFilter(EnumVal* id, StringVal* name) { return RemoveFilter(id, name->AsString()->CheckString()); } -bool Manager::RemoveFilter(zeek::EnumVal* id, const string& name) +bool Manager::RemoveFilter(EnumVal* id, const string& name) { Stream* stream = FindStream(id); if ( ! stream ) @@ -679,7 +679,7 @@ bool Manager::RemoveFilter(zeek::EnumVal* id, const string& name) { Filter* filter = *i; stream->filters.erase(i); - DBG_LOG(zeek::DBG_LOGGING, "Removed filter '%s' from stream '%s'", + DBG_LOG(DBG_LOGGING, "Removed filter '%s' from stream '%s'", filter->name.c_str(), stream->name.c_str()); delete filter; return true; @@ -687,13 +687,13 @@ 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(zeek::DBG_LOGGING, "No filter '%s' for removing from stream '%s'", + DBG_LOG(DBG_LOGGING, "No filter '%s' for removing from stream '%s'", name.c_str(), stream->name.c_str()); return true; } -bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) +bool Manager::Write(EnumVal* id, RecordVal* columns_arg) { Stream* stream = FindStream(id); if ( ! stream ) @@ -702,17 +702,17 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) if ( ! stream->enabled ) return true; - auto columns = columns_arg->CoerceTo({zeek::NewRef{}, stream->columns}); + auto columns = columns_arg->CoerceTo({NewRef{}, stream->columns}); if ( ! columns ) { - zeek::reporter->Error("incompatible log record type"); + reporter->Error("incompatible log record type"); return false; } // Raise the log event. if ( stream->event ) - zeek::event_mgr.Enqueue(stream->event, columns); + event_mgr.Enqueue(stream->event, columns); // Send to each of our filters. for ( list::iterator i = stream->filters.begin(); @@ -737,32 +737,32 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) if ( filter->path_func ) { - zeek::ValPtr path_arg; + ValPtr path_arg; if ( filter->path_val ) - path_arg = {zeek::NewRef{}, filter->path_val}; + path_arg = {NewRef{}, filter->path_val}; else - path_arg = zeek::val_mgr->EmptyString(); + path_arg = val_mgr->EmptyString(); - zeek::ValPtr rec_arg; + ValPtr rec_arg; const auto& rt = filter->path_func->GetType()->Params()->GetFieldType("rec"); - if ( rt->Tag() == zeek::TYPE_RECORD ) - rec_arg = columns->CoerceTo(zeek::cast_intrusive(rt), true); + if ( rt->Tag() == TYPE_RECORD ) + rec_arg = columns->CoerceTo(cast_intrusive(rt), true); else // Can be TYPE_ANY here. rec_arg = columns; - auto v = filter->path_func->Invoke(zeek::IntrusivePtr{zeek::NewRef{}, id}, + auto v = filter->path_func->Invoke(IntrusivePtr{NewRef{}, id}, std::move(path_arg), std::move(rec_arg)); if ( ! v ) return false; - if ( v->GetType()->Tag() != zeek::TYPE_STRING ) + if ( v->GetType()->Tag() != TYPE_STRING ) { - zeek::reporter->Error("path_func did not return string"); + reporter->Error("path_func did not return string"); return false; } @@ -775,7 +775,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) path = v->AsString()->CheckString(); #ifdef DEBUG - DBG_LOG(zeek::DBG_LOGGING, "Path function for filter '%s' on stream '%s' return '%s'", + DBG_LOG(DBG_LOGGING, "Path function for filter '%s' on stream '%s' return '%s'", filter->name.c_str(), stream->name.c_str(), path.c_str()); #endif } @@ -803,9 +803,9 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) CheckFilterWriterConflict(w->second, filter) ); Unref(filter->path_val); - filter->path_val = new zeek::StringVal(new_path.c_str()); + filter->path_val = new StringVal(new_path.c_str()); - zeek::reporter->Warning( + reporter->Warning( "Write using filter '%s' on path '%s' changed to" " use new path '%s' to avoid conflict with filter '%s'", filter->name.c_str(), path.c_str(), new_path.c_str(), @@ -850,31 +850,31 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) if ( filter->field_name_map ) { const char* name = filter->fields[j]->name; - auto fn = zeek::make_intrusive(name); + auto fn = make_intrusive(name); if ( const auto& val = filter->field_name_map->Find(fn) ) { delete [] filter->fields[j]->name; - filter->fields[j]->name = zeek::util::copy_string(val->AsStringVal()->CheckString()); + filter->fields[j]->name = util::copy_string(val->AsStringVal()->CheckString()); } } arg_fields[j] = new threading::Field(*filter->fields[j]); } info = new WriterBackend::WriterInfo; - info->path = zeek::util::copy_string(path.c_str()); - info->network_time = zeek::run_state::network_time; + info->path = util::copy_string(path.c_str()); + info->network_time = run_state::network_time; zeek::detail::HashKey* k; - zeek::IterCookie* c = filter->config->AsTable()->InitForIteration(); + IterCookie* c = filter->config->AsTable()->InitForIteration(); - zeek::TableEntryVal* v; + TableEntryVal* v; while ( (v = filter->config->AsTable()->NextEntry(k, c)) ) { auto index = filter->config->RecreateIndex(*k); string key = index->Idx(0)->AsString()->CheckString(); string value = v->GetVal()->AsString()->CheckString(); - info->config.insert(std::make_pair(zeek::util::copy_string(key.c_str()), zeek::util::copy_string(value.c_str()))); + info->config.insert(std::make_pair(util::copy_string(key.c_str()), util::copy_string(value.c_str()))); delete k; } @@ -902,7 +902,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) DeleteVals(filter->num_fields, vals); #ifdef DEBUG - DBG_LOG(zeek::DBG_LOGGING, "Hook prevented writing to filter '%s' on stream '%s'", + DBG_LOG(DBG_LOGGING, "Hook prevented writing to filter '%s' on stream '%s'", filter->name.c_str(), stream->name.c_str()); #endif return true; @@ -913,7 +913,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) writer->Write(filter->num_fields, vals); #ifdef DEBUG - DBG_LOG(zeek::DBG_LOGGING, "Wrote record to filter '%s' on stream '%s'", + DBG_LOG(DBG_LOGGING, "Wrote record to filter '%s' on stream '%s'", filter->name.c_str(), stream->name.c_str()); #endif } @@ -921,7 +921,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg) return true; } -threading::Value* Manager::ValToLogVal(zeek::Val* val, zeek::Type* ty) +threading::Value* Manager::ValToLogVal(Val* val, Type* ty) { if ( ! ty ) ty = val->GetType().get(); @@ -932,57 +932,57 @@ threading::Value* Manager::ValToLogVal(zeek::Val* val, zeek::Type* ty) threading::Value* lval = new threading::Value(ty->Tag()); switch ( lval->type ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_INT: lval->val.int_val = val->InternalInt(); break; - case zeek::TYPE_ENUM: + case TYPE_ENUM: { const char* s = val->GetType()->AsEnumType()->Lookup(val->InternalInt()); if ( s ) { - lval->val.string_val.data = zeek::util::copy_string(s); + lval->val.string_val.data = util::copy_string(s); lval->val.string_val.length = strlen(s); } else { val->GetType()->Error("enum type does not contain value", val); - lval->val.string_val.data = zeek::util::copy_string(""); + lval->val.string_val.data = util::copy_string(""); lval->val.string_val.length = 0; } break; } - case zeek::TYPE_COUNT: + case TYPE_COUNT: lval->val.uint_val = val->InternalUnsigned(); break; - case zeek::TYPE_PORT: + case TYPE_PORT: lval->val.port_val.port = val->AsPortVal()->Port(); lval->val.port_val.proto = val->AsPortVal()->PortType(); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: val->AsSubNet().ConvertToThreadingValue(&lval->val.subnet_val); break; - case zeek::TYPE_ADDR: + case TYPE_ADDR: val->AsAddr().ConvertToThreadingValue(&lval->val.addr_val); break; - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: lval->val.double_val = val->InternalDouble(); break; - case zeek::TYPE_STRING: + case TYPE_STRING: { - const zeek::String* s = val->AsString(); + const String* s = val->AsString(); char* buf = new char[s->Len()]; memcpy(buf, s->Bytes(), s->Len()); @@ -991,33 +991,33 @@ threading::Value* Manager::ValToLogVal(zeek::Val* val, zeek::Type* ty) break; } - case zeek::TYPE_FILE: + case TYPE_FILE: { - const zeek::File* f = val->AsFile(); + const File* f = val->AsFile(); string s = f->Name(); - lval->val.string_val.data = zeek::util::copy_string(s.c_str()); + lval->val.string_val.data = util::copy_string(s.c_str()); lval->val.string_val.length = s.size(); break; } - case zeek::TYPE_FUNC: + case TYPE_FUNC: { - zeek::ODesc d; - const zeek::Func* f = val->AsFunc(); + ODesc d; + const Func* f = val->AsFunc(); f->Describe(&d); const char* s = d.Description(); - lval->val.string_val.data = zeek::util::copy_string(s); + lval->val.string_val.data = util::copy_string(s); lval->val.string_val.length = strlen(s); break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { auto set = val->AsTableVal()->ToPureListVal(); if ( ! set ) // ToPureListVal has reported an internal warning // already. Just keep going by making something up. - set = zeek::make_intrusive(zeek::TYPE_INT); + set = make_intrusive(TYPE_INT); lval->val.set_val.size = set->Length(); lval->val.set_val.vals = new threading::Value* [lval->val.set_val.size]; @@ -1028,9 +1028,9 @@ threading::Value* Manager::ValToLogVal(zeek::Val* val, zeek::Type* ty) break; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { - zeek::VectorVal* vec = val->AsVectorVal(); + VectorVal* vec = val->AsVectorVal(); lval->val.vector_val.size = vec->Size(); lval->val.vector_val.vals = new threading::Value* [lval->val.vector_val.size]; @@ -1046,30 +1046,30 @@ threading::Value* Manager::ValToLogVal(zeek::Val* val, zeek::Type* ty) } default: - zeek::reporter->InternalError("unsupported type %s for log_write", zeek::type_name(lval->type)); + reporter->InternalError("unsupported type %s for log_write", type_name(lval->type)); } return lval; } threading::Value** Manager::RecordToFilterVals(Stream* stream, Filter* filter, - zeek::RecordVal* columns) + RecordVal* columns) { - zeek::RecordValPtr ext_rec; + RecordValPtr ext_rec; if ( filter->num_ext_fields > 0 ) { - auto res = filter->ext_func->Invoke(zeek::IntrusivePtr{zeek::NewRef{}, filter->path_val}); + auto res = filter->ext_func->Invoke(IntrusivePtr{NewRef{}, filter->path_val}); if ( res ) - ext_rec = {zeek::AdoptRef{}, res.release()->AsRecordVal()}; + ext_rec = {AdoptRef{}, res.release()->AsRecordVal()}; } threading::Value** vals = new threading::Value*[filter->num_fields]; for ( int i = 0; i < filter->num_fields; ++i ) { - zeek::Val* val; + Val* val; if ( i < filter->num_ext_fields ) { if ( ! ext_rec ) @@ -1107,8 +1107,8 @@ threading::Value** Manager::RecordToFilterVals(Stream* stream, Filter* filter, return vals; } -bool Manager::CreateWriterForRemoteLog(zeek::EnumVal* id, zeek::EnumVal* writer, WriterBackend::WriterInfo* info, - int num_fields, const threading::Field* const* fields) +bool Manager::CreateWriterForRemoteLog(EnumVal* id, EnumVal* writer, WriterBackend::WriterInfo* info, + int num_fields, const threading::Field* const* fields) { return CreateWriter(id, writer, info, num_fields, fields, true, false, true); } @@ -1122,7 +1122,7 @@ static void delete_info_and_fields(WriterBackend::WriterInfo* info, int num_fiel delete info; } -WriterFrontend* Manager::CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, WriterBackend::WriterInfo* info, +WriterFrontend* Manager::CreateWriter(EnumVal* id, EnumVal* writer, WriterBackend::WriterInfo* info, int num_fields, const threading::Field* const* fields, bool local, bool remote, bool from_remote, const string& instantiating_filter) { @@ -1151,7 +1151,7 @@ WriterFrontend* Manager::CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, WriterInfo* winfo = new WriterInfo; winfo->type = writer->Ref()->AsEnumVal(); winfo->writer = nullptr; - winfo->open_time = zeek::run_state::network_time; + winfo->open_time = run_state::network_time; winfo->rotation_timer = nullptr; winfo->interval = 0; winfo->postprocessor = nullptr; @@ -1179,7 +1179,7 @@ WriterFrontend* Manager::CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, if ( f->postprocessor ) { delete [] winfo->info->post_proc_func; - winfo->info->post_proc_func = zeek::util::copy_string(f->postprocessor->Name()); + winfo->info->post_proc_func = util::copy_string(f->postprocessor->Name()); } break; @@ -1195,12 +1195,12 @@ WriterFrontend* Manager::CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, if ( winfo->info->post_proc_func && strlen(winfo->info->post_proc_func) ) { - auto func = zeek::id::find_func(winfo->info->post_proc_func); + auto func = id::find_func(winfo->info->post_proc_func); if ( func ) winfo->postprocessor = func.get(); else - zeek::reporter->Warning("failed log postprocessor function lookup: %s\n", + reporter->Warning("failed log postprocessor function lookup: %s\n", winfo->info->post_proc_func); } } @@ -1211,11 +1211,11 @@ WriterFrontend* Manager::CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, // Still need to set the WriterInfo's rotation parameters, which we // computed above. - static auto log_rotate_base_time = zeek::id::find_val("log_rotate_base_time"); + static auto log_rotate_base_time = id::find_val("log_rotate_base_time"); static auto base_time = log_rotate_base_time->AsString()->CheckString(); winfo->info->rotation_interval = winfo->interval; - winfo->info->rotation_base = zeek::util::detail::parse_rotate_base_time(base_time); + winfo->info->rotation_base = util::detail::parse_rotate_base_time(base_time); winfo->writer = new WriterFrontend(*winfo->info, id, writer, local, remote); winfo->writer->Init(num_fields, fields); @@ -1243,7 +1243,7 @@ void Manager::DeleteVals(int num_fields, threading::Value** vals) delete [] vals; } -bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const string& path, int num_fields, +bool Manager::WriteFromRemote(EnumVal* id, EnumVal* writer, const string& path, int num_fields, threading::Value** vals) { Stream* stream = FindStream(id); @@ -1252,9 +1252,9 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st { // Don't know this stream. #ifdef DEBUG - zeek::ODesc desc; + ODesc desc; id->Describe(&desc); - DBG_LOG(zeek::DBG_LOGGING, "unknown stream %s in Manager::Write()", + DBG_LOG(DBG_LOGGING, "unknown stream %s in Manager::Write()", desc.Description()); #endif DeleteVals(num_fields, vals); @@ -1274,9 +1274,9 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st { // Don't know this writer. #ifdef DEBUG - zeek::ODesc desc; + ODesc desc; id->Describe(&desc); - DBG_LOG(zeek::DBG_LOGGING, "unknown writer %s in Manager::Write()", + DBG_LOG(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(zeek::DBG_LOGGING, + DBG_LOG(DBG_LOGGING, "Wrote pre-filtered record to path '%s' on stream '%s'", path.c_str(), stream->name.c_str()); @@ -1294,7 +1294,7 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st void Manager::SendAllWritersTo(const broker::endpoint_info& ei) { - auto et = zeek::id::find_type("Log::Writer")->AsEnumType(); + auto et = id::find_type("Log::Writer")->AsEnumType(); for ( vector::iterator s = streams.begin(); s != streams.end(); ++s ) { @@ -1319,7 +1319,7 @@ void Manager::SendAllWritersTo(const broker::endpoint_info& ei) } } -bool Manager::SetBuf(zeek::EnumVal* id, bool enabled) +bool Manager::SetBuf(EnumVal* id, bool enabled) { Stream* stream = FindStream(id); if ( ! stream ) @@ -1334,7 +1334,7 @@ bool Manager::SetBuf(zeek::EnumVal* id, bool enabled) return true; } -bool Manager::Flush(zeek::EnumVal* id) +bool Manager::Flush(EnumVal* id) { Stream* stream = FindStream(id); if ( ! stream ) @@ -1345,7 +1345,7 @@ bool Manager::Flush(zeek::EnumVal* id) for ( Stream::WriterMap::iterator i = stream->writers.begin(); i != stream->writers.end(); i++ ) - i->second->writer->Flush(zeek::run_state::network_time); + i->second->writer->Flush(run_state::network_time); RemoveDisabledWriters(stream); @@ -1365,7 +1365,7 @@ void Manager::Terminate() } } -bool Manager::EnableRemoteLogs(zeek::EnumVal* stream_id) +bool Manager::EnableRemoteLogs(EnumVal* stream_id) { auto stream = FindStream(stream_id); @@ -1376,7 +1376,7 @@ bool Manager::EnableRemoteLogs(zeek::EnumVal* stream_id) return true; } -bool Manager::DisableRemoteLogs(zeek::EnumVal* stream_id) +bool Manager::DisableRemoteLogs(EnumVal* stream_id) { auto stream = FindStream(stream_id); @@ -1387,7 +1387,7 @@ bool Manager::DisableRemoteLogs(zeek::EnumVal* stream_id) return true; } -bool Manager::RemoteLogsAreEnabled(zeek::EnumVal* stream_id) +bool Manager::RemoteLogsAreEnabled(EnumVal* stream_id) { auto stream = FindStream(stream_id); @@ -1397,7 +1397,7 @@ bool Manager::RemoteLogsAreEnabled(zeek::EnumVal* stream_id) return stream->enable_remote; } -zeek::RecordType* Manager::StreamColumns(zeek::EnumVal* stream_id) +RecordType* Manager::StreamColumns(EnumVal* stream_id) { auto stream = FindStream(stream_id); @@ -1441,14 +1441,14 @@ void RotationTimer::Dispatch(double t, bool is_expire) if ( ! is_expire ) { - winfo->open_time = zeek::run_state::network_time; + winfo->open_time = run_state::network_time; log_mgr->InstallRotationTimer(winfo); } } void Manager::InstallRotationTimer(WriterInfo* winfo) { - if ( zeek::run_state::terminating ) + if ( run_state::terminating ) return; if ( winfo->rotation_timer ) @@ -1464,27 +1464,27 @@ void Manager::InstallRotationTimer(WriterInfo* winfo) // When this is called for the first time, zeek::run_state::network_time can still be // zero. If so, we set a timer which fires immediately but doesn't // rotate when it expires. - if ( ! zeek::run_state::network_time ) + if ( ! run_state::network_time ) winfo->rotation_timer = new RotationTimer(1, winfo, false); else { if ( ! winfo->open_time ) - winfo->open_time = zeek::run_state::network_time; + winfo->open_time = run_state::network_time; - static auto log_rotate_base_time = zeek::id::find_val("log_rotate_base_time"); + static auto log_rotate_base_time = id::find_val("log_rotate_base_time"); static auto base_time = log_rotate_base_time->AsString()->CheckString(); - double base = zeek::util::detail::parse_rotate_base_time(base_time); + double base = util::detail::parse_rotate_base_time(base_time); double delta_t = - zeek::util::detail::calc_next_rotate(zeek::run_state::network_time, rotation_interval, base); + util::detail::calc_next_rotate(run_state::network_time, rotation_interval, base); winfo->rotation_timer = - new RotationTimer(zeek::run_state::network_time + delta_t, winfo, true); + new RotationTimer(run_state::network_time + delta_t, winfo, true); } zeek::detail::timer_mgr->Add(winfo->rotation_timer); - DBG_LOG(zeek::DBG_LOGGING, "Scheduled rotation timer for %s to %.6f", + DBG_LOG(DBG_LOGGING, "Scheduled rotation timer for %s to %.6f", winfo->writer->Name(), winfo->rotation_timer->Time()); } } @@ -1499,18 +1499,18 @@ static std::string format_rotation_time_fallback(time_t t) return buf; } -std::string Manager::FormatRotationPath(zeek::EnumValPtr writer, +std::string Manager::FormatRotationPath(EnumValPtr writer, std::string_view path, double open, double close, bool terminating, - zeek::FuncPtr postprocessor) + FuncPtr postprocessor) { - auto ri = zeek::make_intrusive(zeek::BifType::Record::Log::RotationFmtInfo); + auto ri = make_intrusive(BifType::Record::Log::RotationFmtInfo); ri->Assign(0, std::move(writer)); - ri->Assign(1, path.size(), path.data()); - ri->Assign(2, open); - ri->Assign(3, close); - ri->Assign(4, zeek::val_mgr->Bool(terminating)); - ri->Assign(5, std::move(postprocessor)); + ri->Assign(1, path.size(), path.data()); + ri->Assign(2, open); + ri->Assign(3, close); + ri->Assign(4, val_mgr->Bool(terminating)); + ri->Assign(5, std::move(postprocessor)); std::string rval; @@ -1522,29 +1522,29 @@ std::string Manager::FormatRotationPath(zeek::EnumValPtr writer, auto prefix = rp_val->GetField(1)->AsString()->CheckString(); auto dir = dir_val->AsString()->CheckString(); - if ( ! zeek::util::streq(dir, "") && ! zeek::util::detail::ensure_intermediate_dirs(dir) ) + if ( ! util::streq(dir, "") && ! util::detail::ensure_intermediate_dirs(dir) ) { - zeek::reporter->Error("Failed to create dir '%s' returned by " - "Log::rotation_format_func for path %.*s: %s", - dir, static_cast(path.size()), path.data(), - strerror(errno)); + reporter->Error("Failed to create dir '%s' returned by " + "Log::rotation_format_func for path %.*s: %s", + dir, static_cast(path.size()), path.data(), + strerror(errno)); dir = ""; } - if ( zeek::util::streq(dir, "") ) + if ( util::streq(dir, "") ) rval = prefix; else - rval = zeek::util::fmt("%s/%s", dir, prefix); + rval = util::fmt("%s/%s", dir, prefix); } - catch ( zeek::InterpreterException& e ) + catch ( InterpreterException& e ) { auto rot_str = format_rotation_time_fallback((time_t)open); - rval = zeek::util::fmt("%.*s-%s", static_cast(path.size()), path.data(), - rot_str.data()); - zeek::reporter->Error("Failed to call Log::rotation_format_func for path %.*s " - "continuing with rotation to: ./%s", - static_cast(path.size()), path.data(), rval.data()); + rval = util::fmt("%.*s-%s", static_cast(path.size()), path.data(), + rot_str.data()); + reporter->Error("Failed to call Log::rotation_format_func for path %.*s " + "continuing with rotation to: ./%s", + static_cast(path.size()), path.data(), rval.data()); } return rval; @@ -1552,25 +1552,25 @@ std::string Manager::FormatRotationPath(zeek::EnumValPtr writer, void Manager::Rotate(WriterInfo* winfo) { - DBG_LOG(zeek::DBG_LOGGING, "Rotating %s at %.6f", - winfo->writer->Name(), zeek::run_state::network_time); + DBG_LOG(DBG_LOGGING, "Rotating %s at %.6f", + winfo->writer->Name(), run_state::network_time); - static auto default_ppf = zeek::id::find_func("Log::__default_rotation_postprocessor"); + static auto default_ppf = id::find_func("Log::__default_rotation_postprocessor"); - zeek::FuncPtr ppf; + FuncPtr ppf; if ( winfo->postprocessor ) - ppf = {zeek::NewRef{}, winfo->postprocessor}; + ppf = {NewRef{}, winfo->postprocessor}; else ppf = default_ppf; - auto rotation_path = FormatRotationPath({zeek::NewRef{}, winfo->type}, + auto rotation_path = FormatRotationPath({NewRef{}, winfo->type}, winfo->writer->Info().path, - winfo->open_time, zeek::run_state::network_time, - zeek::run_state::terminating, + winfo->open_time, run_state::network_time, + run_state::terminating, std::move(ppf)); - winfo->writer->Rotate(rotation_path.data(), winfo->open_time, zeek::run_state::network_time, zeek::run_state::terminating); + winfo->writer->Rotate(rotation_path.data(), winfo->open_time, run_state::network_time, run_state::terminating); ++rotations_pending; } @@ -1584,29 +1584,29 @@ bool Manager::FinishedRotation(WriterFrontend* writer, const char* new_name, con if ( ! success ) { - DBG_LOG(zeek::DBG_LOGGING, "Non-successful rotating writer '%s', file '%s' at %.6f,", - writer->Name(), filename, zeek::run_state::network_time); + DBG_LOG(DBG_LOGGING, "Non-successful rotating writer '%s', file '%s' at %.6f,", + writer->Name(), filename, run_state::network_time); return true; } - DBG_LOG(zeek::DBG_LOGGING, "Finished rotating %s at %.6f, new name %s", - writer->Name(), zeek::run_state::network_time, new_name); + DBG_LOG(DBG_LOGGING, "Finished rotating %s at %.6f, new name %s", + writer->Name(), run_state::network_time, new_name); WriterInfo* winfo = FindWriter(writer); if ( ! winfo ) return true; - auto info = zeek::make_intrusive(zeek::BifType::Record::Log::RotationInfo); - info->Assign(0, {zeek::NewRef{}, winfo->type}); - info->Assign(1, zeek::make_intrusive(new_name)); - info->Assign(2, zeek::make_intrusive(winfo->writer->Info().path)); - info->Assign(3, zeek::make_intrusive(open)); - info->Assign(4, zeek::make_intrusive(close)); - info->Assign(5, zeek::val_mgr->Bool(terminating)); + auto info = make_intrusive(BifType::Record::Log::RotationInfo); + info->Assign(0, {NewRef{}, winfo->type}); + info->Assign(1, make_intrusive(new_name)); + info->Assign(2, make_intrusive(winfo->writer->Info().path)); + info->Assign(3, make_intrusive(open)); + info->Assign(4, make_intrusive(close)); + info->Assign(5, val_mgr->Bool(terminating)); - static auto default_ppf = zeek::id::find_func("Log::__default_rotation_postprocessor"); + static auto default_ppf = id::find_func("Log::__default_rotation_postprocessor"); - zeek::Func* func = winfo->postprocessor; + Func* func = winfo->postprocessor; if ( ! func ) func = default_ppf.get(); diff --git a/src/logging/Manager.h b/src/logging/Manager.h index 0a3235a8d4..bbbfcc3b35 100644 --- a/src/logging/Manager.h +++ b/src/logging/Manager.h @@ -28,7 +28,7 @@ class RotationTimer; /** * Singleton class for managing log streams. */ -class Manager : public zeek::plugin::ComponentManager { +class Manager : public plugin::ComponentManager { public: /** @@ -54,10 +54,10 @@ public: * @param rotation_info The fields of a Log::RotationFmtInfo record * to create and pass to Log::rotation_format_func. */ - std::string FormatRotationPath(zeek::EnumValPtr writer, + std::string FormatRotationPath(EnumValPtr writer, std::string_view path, double open, double close, bool terminating, - zeek::FuncPtr postprocesor); + FuncPtr postprocesor); /** * Creates a new log stream. @@ -69,7 +69,7 @@ public: * This method corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool CreateStream(zeek::EnumVal* id, zeek::RecordVal* stream); + bool CreateStream(EnumVal* id, RecordVal* stream); /** * Remove a log stream, stopping all threads. @@ -79,7 +79,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool RemoveStream(zeek::EnumVal* id); + bool RemoveStream(EnumVal* id); /** * Enables a log log stream. @@ -89,7 +89,7 @@ public: * This method corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool EnableStream(zeek::EnumVal* id); + bool EnableStream(EnumVal* id); /** * Disables a log stream. @@ -99,7 +99,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool DisableStream(zeek::EnumVal* id); + bool DisableStream(EnumVal* id); /** * Adds a filter to a log stream. @@ -111,7 +111,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool AddFilter(zeek::EnumVal* id, zeek::RecordVal* filter); + bool AddFilter(EnumVal* id, RecordVal* filter); /** * Removes a filter from a log stream. @@ -123,7 +123,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool RemoveFilter(zeek::EnumVal* id, zeek::StringVal* name); + bool RemoveFilter(EnumVal* id, StringVal* name); /** * Removes a filter from a log stream. @@ -135,7 +135,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool RemoveFilter(zeek::EnumVal* id, const std::string& name); + bool RemoveFilter(EnumVal* id, const std::string& name); /** * Write a record to a log stream. @@ -148,7 +148,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool Write(zeek::EnumVal* id, zeek::RecordVal* columns); + bool Write(EnumVal* id, RecordVal* columns); /** * Create a new log writer frontend. This is exposed so that the @@ -169,7 +169,7 @@ public: * * @return Returns true if the writer was successfully created. */ - bool CreateWriterForRemoteLog(zeek::EnumVal* id, zeek::EnumVal* writer, WriterBackend::WriterInfo* info, + bool CreateWriterForRemoteLog(EnumVal* id, EnumVal* writer, WriterBackend::WriterInfo* info, int num_fields, const threading::Field* const* fields); /** @@ -188,7 +188,7 @@ public: * @param vals An array of log values to write, of size num_fields. * The method takes ownership of the array. */ - bool WriteFromRemote(zeek::EnumVal* stream, zeek::EnumVal* writer, const std::string& path, + bool WriteFromRemote(EnumVal* stream, EnumVal* writer, const std::string& path, int num_fields, threading::Value** vals); /** @@ -207,7 +207,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool SetBuf(zeek::EnumVal* id, bool enabled); + bool SetBuf(EnumVal* id, bool enabled); /** * Flushes a log stream. This flushed all associated writers. @@ -217,7 +217,7 @@ public: * This methods corresponds directly to the internal BiF defined in * logging.bif, which just forwards here. */ - bool Flush(zeek::EnumVal* id); + bool Flush(EnumVal* id); /** * Signals the manager to shutdown at Bro's termination. @@ -229,25 +229,25 @@ public: * @param stream_id the stream to enable remote logs for. * @return true if remote logs are enabled. */ - bool EnableRemoteLogs(zeek::EnumVal* stream_id); + bool EnableRemoteLogs(EnumVal* stream_id); /** * Disable remote logs for a given stream. * @param stream_id the stream to disable remote logs for. * @return true if remote logs are disabled. */ - bool DisableRemoteLogs(zeek::EnumVal* stream_id); + bool DisableRemoteLogs(EnumVal* stream_id); /** * @return true if remote logs are enabled for a given stream. */ - bool RemoteLogsAreEnabled(zeek::EnumVal* stream_id); + bool RemoteLogsAreEnabled(EnumVal* stream_id); /** * @return the type which corresponds to the columns in a log entry for * a given log stream. */ - zeek::RecordType* StreamColumns(zeek::EnumVal* stream_id); + RecordType* StreamColumns(EnumVal* stream_id); protected: friend class WriterFrontend; @@ -257,12 +257,12 @@ protected: // Instantiates a new WriterBackend of the given type (note that // doing so creates a new thread!). - WriterBackend* CreateBackend(WriterFrontend* frontend, zeek::EnumVal* tag); + WriterBackend* CreateBackend(WriterFrontend* frontend, EnumVal* tag); //// Function also used by the RemoteSerializer. // Takes ownership of fields and info. - WriterFrontend* CreateWriter(zeek::EnumVal* id, zeek::EnumVal* writer, WriterBackend::WriterInfo* info, + WriterFrontend* CreateWriter(EnumVal* id, EnumVal* writer, WriterBackend::WriterInfo* info, int num_fields, const threading::Field* const* fields, bool local, bool remote, bool from_remote, const std::string& instantiating_filter=""); @@ -279,15 +279,15 @@ private: struct Stream; struct WriterInfo; - bool TraverseRecord(Stream* stream, Filter* filter, zeek::RecordType* rt, - zeek::TableVal* include, zeek::TableVal* exclude, + bool TraverseRecord(Stream* stream, Filter* filter, RecordType* rt, + TableVal* include, TableVal* exclude, const std::string& path, const std::list& indices); threading::Value** RecordToFilterVals(Stream* stream, Filter* filter, - zeek::RecordVal* columns); + RecordVal* columns); - threading::Value* ValToLogVal(zeek::Val* val, zeek::Type* ty = nullptr); - Stream* FindStream(zeek::EnumVal* id); + threading::Value* ValToLogVal(Val* val, Type* ty = nullptr); + Stream* FindStream(EnumVal* id); void RemoveDisabledWriters(Stream* stream); void InstallRotationTimer(WriterInfo* winfo); void Rotate(WriterInfo* info); @@ -297,7 +297,7 @@ private: std::vector streams; // Indexed by stream enum. int rotations_pending; // Number of rotations not yet finished. - zeek::FuncPtr rotation_format_func; + FuncPtr rotation_format_func; }; } // namespace logging; diff --git a/src/logging/Tag.cc b/src/logging/Tag.cc index 7600ebbf31..3bf6c2871d 100644 --- a/src/logging/Tag.cc +++ b/src/logging/Tag.cc @@ -24,22 +24,22 @@ Tag& Tag::operator=(const Tag&& other) noexcept return *this; } -const zeek::EnumValPtr& Tag::AsVal() const +const EnumValPtr& Tag::AsVal() const { return zeek::Tag::AsVal(log_mgr->GetTagType()); } -zeek::EnumVal* Tag::AsEnumVal() const +EnumVal* Tag::AsEnumVal() const { return AsVal().get(); } -Tag::Tag(zeek::EnumValPtr val) +Tag::Tag(EnumValPtr val) : zeek::Tag(std::move(val)) { } -Tag::Tag(zeek::EnumVal* val) - : zeek::Tag({zeek::NewRef{}, val}) +Tag::Tag(EnumVal* val) + : zeek::Tag({NewRef{}, val}) { } } // namespace zeek::logging diff --git a/src/logging/Tag.h b/src/logging/Tag.h index 17622027a5..ccb7963b93 100644 --- a/src/logging/Tag.h +++ b/src/logging/Tag.h @@ -94,16 +94,16 @@ public: * * @param etype the script-layer enum type associated with the tag. */ - const zeek::EnumValPtr& AsVal() const; + const EnumValPtr& AsVal() const; [[deprecated("Remove in v4.1. Use AsVal() instead.")]] - zeek::EnumVal* AsEnumVal() const; + EnumVal* AsEnumVal() const; static const Tag Error; protected: - friend class zeek::plugin::ComponentManager; - friend class zeek::plugin::TaggedComponent; + friend class plugin::ComponentManager; + friend class plugin::TaggedComponent; /** * Constructor. @@ -122,10 +122,10 @@ protected: * * @param val An enum value of script type \c Log::Writer. */ - explicit Tag(zeek::EnumValPtr val); + explicit Tag(EnumValPtr val); [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] - explicit Tag(zeek::EnumVal* val); + explicit Tag(EnumVal* val); }; } // namespace zeek::logging diff --git a/src/logging/WriterBackend.cc b/src/logging/WriterBackend.cc index 6658f880c6..d4c6c456e0 100644 --- a/src/logging/WriterBackend.cc +++ b/src/logging/WriterBackend.cc @@ -22,7 +22,7 @@ public: RotationFinishedMessage(WriterFrontend* writer, const char* new_name, const char* old_name, double open, double close, bool success, bool terminating) : threading::OutputMessage("RotationFinished", writer), - new_name(zeek::util::copy_string(new_name)), old_name(zeek::util::copy_string(old_name)), open(open), + new_name(util::copy_string(new_name)), old_name(util::copy_string(old_name)), open(open), close(close), success(success), terminating(terminating) { } ~RotationFinishedMessage() override @@ -97,8 +97,8 @@ bool WriterBackend::WriterInfo::FromBroker(broker::data d) if ( ! (bpath && brotation_base && brotation_interval && bnetwork_time && bconfig && bppf) ) return false; - path = zeek::util::copy_string(bpath->c_str()); - post_proc_func = zeek::util::copy_string(bppf->c_str()); + path = util::copy_string(bpath->c_str()); + post_proc_func = util::copy_string(bppf->c_str()); rotation_base = *brotation_base; rotation_interval = *brotation_interval; network_time = *bnetwork_time; @@ -111,7 +111,7 @@ bool WriterBackend::WriterInfo::FromBroker(broker::data d) if ( ! (k && v) ) return false; - auto p = std::make_pair(zeek::util::copy_string(k->c_str()), zeek::util::copy_string(v->c_str())); + auto p = std::make_pair(util::copy_string(k->c_str()), util::copy_string(v->c_str())); config.insert(p); } @@ -205,7 +205,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(zeek::DBG_LOGGING, msg); + Debug(DBG_LOGGING, msg); #endif DeleteVals(num_writes, vals); @@ -223,7 +223,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(zeek::DBG_LOGGING, msg); + Debug(DBG_LOGGING, msg); #endif DisableFrontend(); DeleteVals(num_writes, vals); diff --git a/src/logging/WriterBackend.h b/src/logging/WriterBackend.h index c10d8e22f2..a3b45fa0ad 100644 --- a/src/logging/WriterBackend.h +++ b/src/logging/WriterBackend.h @@ -50,7 +50,7 @@ public: struct WriterInfo { // Structure takes ownership of these strings. - typedef std::map config_map; + typedef std::map config_map; /** * A string left to the interpretation of the writer @@ -98,15 +98,15 @@ public: WriterInfo(const WriterInfo& other) { - path = other.path ? zeek::util::copy_string(other.path) : nullptr; - post_proc_func = other.post_proc_func ? zeek::util::copy_string(other.post_proc_func) : nullptr; + path = other.path ? util::copy_string(other.path) : nullptr; + post_proc_func = other.post_proc_func ? util::copy_string(other.post_proc_func) : nullptr; rotation_interval = other.rotation_interval; rotation_base = other.rotation_base; network_time = other.network_time; for ( config_map::const_iterator i = other.config.begin(); i != other.config.end(); i++ ) - config.insert(std::make_pair(zeek::util::copy_string(i->first), - zeek::util::copy_string(i->second))); + config.insert(std::make_pair(util::copy_string(i->first), + util::copy_string(i->second))); } ~WriterInfo() diff --git a/src/logging/WriterFrontend.cc b/src/logging/WriterFrontend.cc index 9a57ac3d30..55c7cc48c6 100644 --- a/src/logging/WriterFrontend.cc +++ b/src/logging/WriterFrontend.cc @@ -14,11 +14,11 @@ namespace zeek::logging { // Messages sent from frontend to backend (i.e., "InputMessages"). -class InitMessage final : public zeek::threading::InputMessage +class InitMessage final : public threading::InputMessage { public: InitMessage(WriterBackend* backend, const int num_fields, const Field* const* fields) - : zeek::threading::InputMessage("Init", backend), + : threading::InputMessage("Init", backend), num_fields(num_fields), fields(fields) {} @@ -29,14 +29,14 @@ private: const Field * const* fields; }; -class RotateMessage final : public zeek::threading::InputMessage +class RotateMessage final : public threading::InputMessage { public: RotateMessage(WriterBackend* backend, WriterFrontend* frontend, const char* rotated_path, const double open, const double close, const bool terminating) - : zeek::threading::InputMessage("Rotate", backend), + : threading::InputMessage("Rotate", backend), frontend(frontend), - rotated_path(zeek::util::copy_string(rotated_path)), open(open), + rotated_path(util::copy_string(rotated_path)), open(open), close(close), terminating(terminating) { } virtual ~RotateMessage() { delete [] rotated_path; } @@ -51,11 +51,11 @@ private: const bool terminating; }; -class WriteMessage final : public zeek::threading::InputMessage +class WriteMessage final : public threading::InputMessage { public: WriteMessage(WriterBackend* backend, int num_fields, int num_writes, Value*** vals) - : zeek::threading::InputMessage("Write", backend), + : threading::InputMessage("Write", backend), num_fields(num_fields), num_writes(num_writes), vals(vals) {} bool Process() override { return Object()->Write(num_fields, num_writes, vals); } @@ -66,11 +66,11 @@ private: Value ***vals; }; -class SetBufMessage final : public zeek::threading::InputMessage +class SetBufMessage final : public threading::InputMessage { public: SetBufMessage(WriterBackend* backend, const bool enabled) - : zeek::threading::InputMessage("SetBuf", backend), + : threading::InputMessage("SetBuf", backend), enabled(enabled) { } bool Process() override { return Object()->SetBuf(enabled); } @@ -79,11 +79,11 @@ private: const bool enabled; }; -class FlushMessage final : public zeek::threading::InputMessage +class FlushMessage final : public threading::InputMessage { public: FlushMessage(WriterBackend* backend, double network_time) - : zeek::threading::InputMessage("Flush", backend), + : threading::InputMessage("Flush", backend), network_time(network_time) {} bool Process() override { return Object()->Flush(network_time); } @@ -93,8 +93,8 @@ private: // Frontend methods. -WriterFrontend::WriterFrontend(const WriterBackend::WriterInfo& arg_info, zeek::EnumVal* arg_stream, - zeek::EnumVal* arg_writer, bool arg_local, bool arg_remote) +WriterFrontend::WriterFrontend(const WriterBackend::WriterInfo& arg_info, EnumVal* arg_stream, + EnumVal* arg_writer, bool arg_local, bool arg_remote) { stream = arg_stream; writer = arg_writer; @@ -113,7 +113,7 @@ WriterFrontend::WriterFrontend(const WriterBackend::WriterInfo& arg_info, zeek:: fields = nullptr; const char* w = arg_writer->GetType()->AsEnumType()->Lookup(arg_writer->InternalInt()); - name = zeek::util::copy_string(zeek::util::fmt("%s/%s", arg_info.path, w)); + name = util::copy_string(util::fmt("%s/%s", arg_info.path, w)); if ( local ) { @@ -158,7 +158,7 @@ void WriterFrontend::Init(int arg_num_fields, const Field* const * arg_fields) return; if ( initialized ) - zeek::reporter->InternalError("writer initialize twice"); + reporter->InternalError("writer initialize twice"); num_fields = arg_num_fields; fields = arg_fields; @@ -196,8 +196,8 @@ void WriterFrontend::Write(int arg_num_fields, Value** vals) if ( arg_num_fields != num_fields ) { - zeek::reporter->Warning("WriterFrontend %s expected %d fields in write, got %d. Skipping line.", - name, num_fields, arg_num_fields); + reporter->Warning("WriterFrontend %s expected %d fields in write, got %d. Skipping line.", + name, num_fields, arg_num_fields); DeleteVals(arg_num_fields, vals); return; } @@ -226,7 +226,7 @@ void WriterFrontend::Write(int arg_num_fields, Value** vals) write_buffer[write_buffer_pos++] = vals; - if ( write_buffer_pos >= WRITER_BUFFER_SIZE || ! buf || zeek::run_state::terminating ) + if ( write_buffer_pos >= WRITER_BUFFER_SIZE || ! buf || run_state::terminating ) // Buffer full (or no bufferin desired or termiating). FlushWriteBuffer(); diff --git a/src/logging/WriterFrontend.h b/src/logging/WriterFrontend.h index 74f07ad323..345ab5eac9 100644 --- a/src/logging/WriterFrontend.h +++ b/src/logging/WriterFrontend.h @@ -38,8 +38,8 @@ public: * * Frontends must only be instantiated by the main thread. */ - WriterFrontend(const WriterBackend::WriterInfo& info, zeek::EnumVal* stream, - zeek::EnumVal* writer, bool local, bool remote); + WriterFrontend(const WriterBackend::WriterInfo& info, EnumVal* stream, + EnumVal* writer, bool local, bool remote); /** * Destructor. @@ -188,8 +188,8 @@ protected: void DeleteVals(int num_fields, threading::Value** vals); - zeek::EnumVal* stream; - zeek::EnumVal* writer; + EnumVal* stream; + EnumVal* writer; WriterBackend* backend; // The backend we have instantiated. bool disabled; // True if disabled. diff --git a/src/make_dbg_constants.py b/src/make_dbg_constants.py index d86fbbfe5e..5173b24652 100644 --- a/src/make_dbg_constants.py +++ b/src/make_dbg_constants.py @@ -26,11 +26,11 @@ inputfile = sys.argv[1] init_tmpl = ''' \t{ -\t\tzeek::detail::DebugCmdInfo* info; +\t\tDebugCmdInfo* info; \t\t%(name_init)s -\t\tinfo = new zeek::detail::DebugCmdInfo(%(cmd)s, names, %(num_names)s, %(resume)s, "%(help)s", +\t\tinfo = new DebugCmdInfo(%(cmd)s, names, %(num_names)s, %(resume)s, "%(help)s", \t\t %(repeatable)s); -\t\tzeek::detail::g_DebugCmdInfos.push_back(info); +\t\tg_DebugCmdInfos.push_back(info); \t} ''' @@ -49,7 +49,8 @@ init_str = ''' // #include "util.h" -void zeek::detail::init_global_dbg_constants () { +namespace zeek::detail {\n +void init_global_dbg_constants () { ''' % inputfile def outputrecord(): @@ -105,7 +106,7 @@ for line in inputf: # output the last record outputrecord() -init_str += "\t\n}\n" +init_str += "\t\n}\n\n} // namespace zeek::detail\n" enum_str += "\tdcLast\n};\n" debugcmds = open("DebugCmdConstants.h", "w") diff --git a/src/net_util.cc b/src/net_util.cc index 54b6c22dae..86f23cc4bf 100644 --- a/src/net_util.cc +++ b/src/net_util.cc @@ -37,7 +37,7 @@ int ones_complement_checksum(const void* p, int b, uint32_t sum) return sum; } -int ones_complement_checksum(const zeek::IPAddr& a, uint32_t sum) +int ones_complement_checksum(const IPAddr& a, uint32_t sum) { const uint32_t* bytes; int len = a.GetBytes(&bytes); @@ -60,7 +60,7 @@ int icmp_checksum(const struct icmp* icmpp, int len) } #ifdef ENABLE_MOBILE_IPV6 -int mobility_header_checksum(const zeek::IP_Hdr* ip) +int mobility_header_checksum(const IP_Hdr* ip) { const ip6_mobility* mh = ip->MobilityHeader(); @@ -85,7 +85,7 @@ int mobility_header_checksum(const zeek::IP_Hdr* ip) } #endif -int icmp6_checksum(const struct icmp* icmpp, const zeek::IP_Hdr* ip, int len) +int icmp6_checksum(const struct icmp* icmpp, const IP_Hdr* ip, int len) { // ICMP6 uses the same checksum function as ICMP4 but a different // pseudo-header over which it is computed. @@ -133,8 +133,8 @@ char addr_to_class(uint32_t addr) return 'A'; } -const char* fmt_conn_id(const zeek::IPAddr& src_addr, uint32_t src_port, - const zeek::IPAddr& dst_addr, uint32_t dst_port) +const char* fmt_conn_id(const IPAddr& src_addr, uint32_t src_port, + const IPAddr& dst_addr, uint32_t dst_port) { static char buffer[512]; @@ -148,8 +148,8 @@ const char* fmt_conn_id(const zeek::IPAddr& src_addr, uint32_t src_port, const char* fmt_conn_id(const uint32_t* src_addr, uint32_t src_port, const uint32_t* dst_addr, uint32_t dst_port) { - zeek::IPAddr src(IPv6, src_addr, zeek::IPAddr::Network); - zeek::IPAddr dst(IPv6, dst_addr, zeek::IPAddr::Network); + IPAddr src(IPv6, src_addr, IPAddr::Network); + IPAddr dst(IPv6, dst_addr, IPAddr::Network); return fmt_conn_id(src, src_port, dst, dst_port); } diff --git a/src/net_util.h b/src/net_util.h index cc3b0b423c..b9d5d86e2d 100644 --- a/src/net_util.h +++ b/src/net_util.h @@ -124,13 +124,13 @@ namespace zeek { // Returns the ones-complement checksum of a chunk of b short-aligned bytes. extern int ones_complement_checksum(const void* p, int b, uint32_t sum); -extern int ones_complement_checksum(const zeek::IPAddr& a, uint32_t sum); +extern int ones_complement_checksum(const IPAddr& a, uint32_t sum); -extern int icmp6_checksum(const struct icmp* icmpp, const zeek::IP_Hdr* ip, int len); +extern int icmp6_checksum(const struct icmp* icmpp, const IP_Hdr* ip, int len); extern int icmp_checksum(const struct icmp* icmpp, int len); #ifdef ENABLE_MOBILE_IPV6 -extern int mobility_header_checksum(const zeek::IP_Hdr* ip); +extern int mobility_header_checksum(const IP_Hdr* ip); #endif // True if sequence # a is between b and c (b <= a <= c). It must be true @@ -152,8 +152,8 @@ inline int32_t seq_delta(uint32_t a, uint32_t b) // Returns 'A', 'B', 'C' or 'D' extern char addr_to_class(uint32_t addr); -extern const char* fmt_conn_id(const zeek::IPAddr& src_addr, uint32_t src_port, - const zeek::IPAddr& dst_addr, uint32_t dst_port); +extern const char* fmt_conn_id(const IPAddr& src_addr, uint32_t src_port, + const IPAddr& dst_addr, uint32_t dst_port); extern const char* fmt_conn_id(const uint32_t* src_addr, uint32_t src_port, const uint32_t* dst_addr, uint32_t dst_port); diff --git a/src/plugin/Component.cc b/src/plugin/Component.cc index bd51703214..df9b048f76 100644 --- a/src/plugin/Component.cc +++ b/src/plugin/Component.cc @@ -5,13 +5,13 @@ #include "../Desc.h" #include "../Reporter.h" -using namespace zeek::plugin; +namespace zeek::plugin { Component::Component(component::Type arg_type, const std::string& arg_name) { type = arg_type; name = arg_name; - canon_name = zeek::util::canonify_name(name); + canon_name = util::canonify_name(name); } Component::~Component() @@ -28,7 +28,7 @@ component::Type Component::Type() const return type; } -void Component::Describe(zeek::ODesc* d) const +void Component::Describe(ODesc* d) const { d->Add(" "); d->Add("["); @@ -75,3 +75,5 @@ void Component::Describe(zeek::ODesc* d) const DoDescribe(d); d->Add(")"); } + +} // namespace zeek::plugin diff --git a/src/plugin/Component.h b/src/plugin/Component.h index 538730f7b1..72237adac7 100644 --- a/src/plugin/Component.h +++ b/src/plugin/Component.h @@ -83,7 +83,7 @@ public: * * @param d The description object to use. */ - void Describe(zeek::ODesc* d) const; + void Describe(ODesc* d) const; protected: /** @@ -93,7 +93,7 @@ protected: * * @param d The description object to use. */ - virtual void DoDescribe(zeek::ODesc* d) const { } + virtual void DoDescribe(ODesc* d) const { } private: // Disable. diff --git a/src/plugin/ComponentManager.h b/src/plugin/ComponentManager.h index 4f4bf1ab1b..6e62875c62 100644 --- a/src/plugin/ComponentManager.h +++ b/src/plugin/ComponentManager.h @@ -51,10 +51,10 @@ public: /** * @return The enum type associated with the script-layer "Tag". */ - const zeek::EnumTypePtr& GetTagType() const; + const EnumTypePtr& GetTagType() const; [[deprecated("Remove in v4.1. Use GetTagType() instead.")]] - zeek::EnumType* GetTagEnumType() const; + EnumType* GetTagEnumType() const; /** * Get a component name from its tag. @@ -127,7 +127,7 @@ public: private: std::string module; /**< Script layer module in which component tags live. */ - zeek::EnumTypePtr tag_enum_type; /**< Enum type of component tags. */ + EnumTypePtr tag_enum_type; /**< Enum type of component tags. */ std::map components_by_name; std::map components_by_tag; std::map components_by_val; @@ -136,7 +136,7 @@ private: template ComponentManager::ComponentManager(const std::string& arg_module, const std::string& local_id) : module(arg_module), - tag_enum_type(zeek::make_intrusive(module + "::" + local_id)) + tag_enum_type(make_intrusive(module + "::" + local_id)) { auto id = zeek::detail::install_ID(local_id.c_str(), module.c_str(), true, true); zeek::detail::add_type(id.get(), tag_enum_type, nullptr); @@ -162,13 +162,13 @@ std::list ComponentManager::GetComponents() const } template -const zeek::EnumTypePtr& ComponentManager::GetTagType() const +const EnumTypePtr& ComponentManager::GetTagType() const { return tag_enum_type; } template -zeek::EnumType* ComponentManager::GetTagEnumType() const +EnumType* ComponentManager::GetTagEnumType() const { return tag_enum_type.get(); } @@ -200,7 +200,7 @@ const std::string& ComponentManager::GetComponentName(EnumValPtr val) cons template const std::string& ComponentManager::GetComponentName(Val* val) const { - return GetComponentName(T({zeek::NewRef{}, val->AsEnumVal()})); + return GetComponentName(T({NewRef{}, val->AsEnumVal()})); } template @@ -221,7 +221,7 @@ template C* ComponentManager::Lookup(const std::string& name) const { typename std::map::const_iterator i = - components_by_name.find(zeek::util::to_upper(name)); + components_by_name.find(util::to_upper(name)); return i != components_by_name.end() ? i->second : 0; } @@ -250,7 +250,7 @@ void ComponentManager::RegisterComponent(C* component, reporter->FatalError("Component '%s::%s' defined more than once", module.c_str(), cname.c_str()); - DBG_LOG(zeek::DBG_PLUGINS, "Registering component %s (tag %s)", + DBG_LOG(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)); @@ -259,7 +259,7 @@ void ComponentManager::RegisterComponent(C* component, component->Tag().AsVal()->InternalInt(), component)); // Install an identfier for enum value - std::string id = zeek::util::fmt("%s%s", prefix.c_str(), cname.c_str()); + std::string id = util::fmt("%s%s", prefix.c_str(), cname.c_str()); tag_enum_type->AddName(module, id.c_str(), component->Tag().AsVal()->InternalInt(), true, nullptr); diff --git a/src/plugin/Manager.cc b/src/plugin/Manager.cc index d391bdfa28..51579b206e 100644 --- a/src/plugin/Manager.cc +++ b/src/plugin/Manager.cc @@ -19,7 +19,8 @@ #include "../input.h" using namespace std; -using namespace zeek::plugin; + +namespace zeek::plugin { Plugin* Manager::current_plugin = nullptr; const char* Manager::current_dir = nullptr; @@ -63,9 +64,9 @@ void Manager::SearchDynamicPlugins(const std::string& dir) return; } - if ( ! zeek::util::is_dir(dir) ) + if ( ! util::is_dir(dir) ) { - DBG_LOG(zeek::DBG_PLUGINS, "Not a valid plugin directory: %s", dir.c_str()); + DBG_LOG(DBG_PLUGINS, "Not a valid plugin directory: %s", dir.c_str()); return; } @@ -73,7 +74,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir) const std::string magic = dir + "/__bro_plugin__"; - if ( zeek::util::is_file(magic) ) + if ( util::is_file(magic) ) { // It's a plugin, get it's name. std::ifstream in(magic.c_str()); @@ -83,22 +84,22 @@ void Manager::SearchDynamicPlugins(const std::string& dir) std::string name; std::getline(in, name); - zeek::util::strstrip(name); - string lower_name = zeek::util::strtolower(name); + util::strstrip(name); + string lower_name = util::strtolower(name); if ( name.empty() ) reporter->FatalError("empty plugin magic file %s", magic.c_str()); if ( dynamic_plugins.find(lower_name) != dynamic_plugins.end() ) { - DBG_LOG(zeek::DBG_PLUGINS, "Found already known plugin %s in %s, ignoring", name.c_str(), dir.c_str()); + DBG_LOG(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(zeek::DBG_PLUGINS, "Found plugin %s in %s", name.c_str(), dir.c_str()); + DBG_LOG(DBG_PLUGINS, "Found plugin %s in %s", name.c_str(), dir.c_str()); return; } @@ -108,7 +109,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir) if ( ! d ) { - DBG_LOG(zeek::DBG_PLUGINS, "Cannot open directory %s", dir.c_str()); + DBG_LOG(DBG_PLUGINS, "Cannot open directory %s", dir.c_str()); return; } @@ -128,7 +129,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir) if( stat(path.c_str(), &st) < 0 ) { - DBG_LOG(zeek::DBG_PLUGINS, "Cannot stat %s: %s", path.c_str(), strerror(errno)); + DBG_LOG(DBG_PLUGINS, "Cannot stat %s: %s", path.c_str(), strerror(errno)); continue; } @@ -141,7 +142,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir) bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_not_found) { - dynamic_plugin_map::iterator m = dynamic_plugins.find(zeek::util::strtolower(name)); + dynamic_plugin_map::iterator m = dynamic_plugins.find(util::strtolower(name)); if ( m == dynamic_plugins.end() ) { @@ -153,7 +154,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ // this should be rare to begin with. plugin_list* all_plugins = Manager::ActivePluginsInternal(); - for ( plugin::Manager::plugin_list::const_iterator i = all_plugins->begin(); i != all_plugins->end(); i++ ) + for ( Manager::plugin_list::const_iterator i = all_plugins->begin(); i != all_plugins->end(); i++ ) { if ( (*i)->Name() == name ) return true; @@ -172,55 +173,55 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ std::string dir = m->second + "/"; - DBG_LOG(zeek::DBG_PLUGINS, "Activating plugin %s", name.c_str()); + DBG_LOG(DBG_PLUGINS, "Activating plugin %s", name.c_str()); // Add the "scripts" and "bif" directories to ZEEKPATH. std::string scripts = dir + "scripts"; - if ( zeek::util::is_dir(scripts) ) + if ( util::is_dir(scripts) ) { - DBG_LOG(zeek::DBG_PLUGINS, " Adding %s to ZEEKPATH", scripts.c_str()); - zeek::util::detail::add_to_zeek_path(scripts); + DBG_LOG(DBG_PLUGINS, " Adding %s to ZEEKPATH", scripts.c_str()); + util::detail::add_to_zeek_path(scripts); } string init; // First load {scripts}/__preload__.zeek automatically. - for (const string& ext : zeek::util::detail::script_extensions) + for (const string& ext : util::detail::script_extensions) { init = dir + "scripts/__preload__" + ext; - if ( zeek::util::is_file(init) ) + if ( util::is_file(init) ) { - DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str()); - zeek::util::detail::warn_if_legacy_script(init); + DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str()); + util::detail::warn_if_legacy_script(init); scripts_to_load.push_back(init); break; } } // Load {bif,scripts}/__load__.zeek automatically. - for (const string& ext : zeek::util::detail::script_extensions) + for (const string& ext : util::detail::script_extensions) { init = dir + "lib/bif/__load__" + ext; - if ( zeek::util::is_file(init) ) + if ( util::is_file(init) ) { - DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str()); - zeek::util::detail::warn_if_legacy_script(init); + DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str()); + util::detail::warn_if_legacy_script(init); scripts_to_load.push_back(init); break; } } - for (const string& ext : zeek::util::detail::script_extensions) + for (const string& ext : util::detail::script_extensions) { init = dir + "scripts/__load__" + ext; - if ( zeek::util::is_file(init) ) + if ( util::is_file(init) ) { - DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str()); - zeek::util::detail::warn_if_legacy_script(init); + DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str()); + util::detail::warn_if_legacy_script(init); scripts_to_load.push_back(init); break; } @@ -230,7 +231,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ string dypattern = dir + "/lib/*." + HOST_ARCHITECTURE + DYNAMIC_PLUGIN_SUFFIX; - DBG_LOG(zeek::DBG_PLUGINS, " Searching for shared libraries %s", dypattern.c_str()); + DBG_LOG(DBG_PLUGINS, " Searching for shared libraries %s", dypattern.c_str()); glob_t gl; @@ -256,10 +257,10 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ current_plugin->SetDynamic(true); current_plugin->DoConfigure(); - DBG_LOG(zeek::DBG_PLUGINS, " InitialzingComponents"); + DBG_LOG(DBG_PLUGINS, " InitialzingComponents"); current_plugin->InitializeComponents(); - plugins_by_path.insert(std::make_pair(zeek::util::detail::normalize_path(dir), current_plugin)); + plugins_by_path.insert(std::make_pair(util::detail::normalize_path(dir), current_plugin)); // We execute the pre-script initialization here; this in // fact could be *during* script initialization if we got @@ -268,7 +269,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ // Make sure the name the plugin reports is consistent with // what we expect from its magic file. - if ( zeek::util::strtolower(current_plugin->Name()) != zeek::util::strtolower(name) ) + if ( util::strtolower(current_plugin->Name()) != util::strtolower(name) ) reporter->FatalError("inconsistent plugin name: %s vs %s", current_plugin->Name().c_str(), name.c_str()); @@ -276,7 +277,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ current_sopath = nullptr; current_plugin = nullptr; - DBG_LOG(zeek::DBG_PLUGINS, " Loaded %s", path); + DBG_LOG(DBG_PLUGINS, " Loaded %s", path); } globfree(&gl); @@ -284,7 +285,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_ else { - DBG_LOG(zeek::DBG_PLUGINS, " No shared library found"); + DBG_LOG(DBG_PLUGINS, " No shared library found"); } // Mark this plugin as activated by clearing the path. @@ -306,7 +307,7 @@ bool Manager::ActivateDynamicPlugins(bool all) { // Activate plugins that our environment tells us to. vector p; - zeek::util::tokenize_string(zeek::util::zeek_plugin_activate(), ",", &p); + util::tokenize_string(util::zeek_plugin_activate(), ",", &p); for ( size_t n = 0; n < p.size(); ++n ) ActivateDynamicPluginInternal(p[n], true); @@ -337,7 +338,7 @@ void Manager::UpdateInputFiles() static bool plugin_cmp(const Plugin* a, const Plugin* b) { - return zeek::util::strtolower(a->Name()) < zeek::util::strtolower(b->Name()); + return util::strtolower(a->Name()) < util::strtolower(b->Name()); } void Manager::RegisterPlugin(Plugin *plugin) @@ -346,7 +347,7 @@ void Manager::RegisterPlugin(Plugin *plugin) if ( current_dir && current_sopath ) // A dynamic plugin, record its location. - plugin->SetPluginLocation(zeek::util::detail::normalize_path(current_dir), current_sopath); + plugin->SetPluginLocation(util::detail::normalize_path(current_dir), current_sopath); current_plugin = plugin; } @@ -355,7 +356,7 @@ void Manager::RegisterBifFile(const char* plugin, bif_init_func c) { bif_init_func_map* bifs = BifFilesInternal(); - std::string lower_plugin = zeek::util::strtolower(plugin); + std::string lower_plugin = util::strtolower(plugin); bif_init_func_map::iterator i = bifs->find(lower_plugin); if ( i == bifs->end() ) @@ -398,7 +399,7 @@ void Manager::InitBifs() for ( plugin_list::iterator i = Manager::ActivePluginsInternal()->begin(); i != Manager::ActivePluginsInternal()->end(); i++ ) { - bif_init_func_map::const_iterator b = bifs->find(zeek::util::strtolower((*i)->Name())); + bif_init_func_map::const_iterator b = bifs->find(util::strtolower((*i)->Name())); if ( b != bifs->end() ) { @@ -447,7 +448,7 @@ Manager::inactive_plugin_list Manager::InactivePlugins() const for ( plugin_list::const_iterator j = all->begin(); j != all->end(); j++ ) { - if ( (*i).first == zeek::util::strtolower((*j)->Name()) ) + if ( (*i).first == util::strtolower((*j)->Name()) ) { found = true; break; @@ -483,10 +484,10 @@ Manager::bif_init_func_map* Manager::BifFilesInternal() Plugin* Manager::LookupPluginByPath(std::string_view _path) { - auto path = zeek::util::detail::normalize_path(_path); + auto path = util::detail::normalize_path(_path); - if ( zeek::util::is_file(path) ) - path = zeek::util::SafeDirname(path).result; + if ( util::is_file(path) ) + path = util::SafeDirname(path).result; while ( path.size() ) { @@ -509,28 +510,28 @@ Plugin* Manager::LookupPluginByPath(std::string_view _path) static bool hook_cmp(std::pair a, std::pair b) { if ( a.first == b.first ) - return zeek::util::strtolower(a.second->Name()) < zeek::util::strtolower(a.second->Name()); + return util::strtolower(a.second->Name()) < util::strtolower(a.second->Name()); // Reverse sort. return a.first > b.first; } -std::list > Manager::HooksEnabledForPlugin(const Plugin* plugin) const +std::list > Manager::HooksEnabledForPlugin(const Plugin* plugin) const { - std::list > enabled; + std::list > enabled; for ( int i = 0; i < NUM_HOOKS; i++ ) { if ( hook_list* l = hooks[i] ) for ( const auto& [hook, hook_plugin] : *l ) if ( hook_plugin == plugin ) - enabled.push_back(std::make_pair(static_cast(i), hook)); + enabled.push_back(std::make_pair(static_cast(i), hook)); } return enabled; } -void Manager::EnableHook(zeek::plugin::HookType hook, Plugin* plugin, int prio) +void Manager::EnableHook(HookType hook, Plugin* plugin, int prio) { if ( ! hooks[hook] ) hooks[hook] = new hook_list; @@ -548,7 +549,7 @@ void Manager::EnableHook(zeek::plugin::HookType hook, Plugin* plugin, int prio) l->sort(hook_cmp); } -void Manager::DisableHook(zeek::plugin::HookType hook, Plugin* plugin) +void Manager::DisableHook(HookType hook, Plugin* plugin) { hook_list* l = hooks[hook]; @@ -573,7 +574,7 @@ void Manager::DisableHook(zeek::plugin::HookType hook, Plugin* plugin) void Manager::RequestEvent(EventHandlerPtr handler, Plugin* plugin) { - DBG_LOG(zeek::DBG_PLUGINS, "Plugin %s requested event %s", + DBG_LOG(DBG_PLUGINS, "Plugin %s requested event %s", plugin->Name().c_str(), handler->Name()); handler->SetGenerateAlways(); } @@ -587,15 +588,15 @@ int Manager::HookLoadFile(const Plugin::LoadType type, const string& file, const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(type)); args.push_back(HookArgument(file)); args.push_back(HookArgument(resolved)); - MetaHookPre(zeek::plugin::HOOK_LOAD_FILE, args); + MetaHookPre(HOOK_LOAD_FILE, args); } - hook_list* l = hooks[zeek::plugin::HOOK_LOAD_FILE]; + hook_list* l = hooks[HOOK_LOAD_FILE]; int rc = -1; @@ -610,20 +611,20 @@ int Manager::HookLoadFile(const Plugin::LoadType type, const string& file, const break; } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_LOAD_FILE, args, HookArgument(rc)); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_LOAD_FILE, args, HookArgument(rc)); return rc; } -std::pair -Manager::HookCallFunction(const zeek::Func* func, zeek::detail::Frame* parent, - zeek::Args* vecargs) const +std::pair +Manager::HookCallFunction(const Func* func, zeek::detail::Frame* parent, + Args* vecargs) const { HookArgumentList args; ValPList vargs; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { vargs.resize(vecargs->size()); @@ -633,12 +634,12 @@ Manager::HookCallFunction(const zeek::Func* func, zeek::detail::Frame* parent, args.push_back(HookArgument(func)); args.push_back(HookArgument(parent)); args.push_back(HookArgument(&vargs)); - MetaHookPre(zeek::plugin::HOOK_CALL_FUNCTION, args); + MetaHookPre(HOOK_CALL_FUNCTION, args); } - hook_list* l = hooks[zeek::plugin::HOOK_CALL_FUNCTION]; + hook_list* l = hooks[HOOK_CALL_FUNCTION]; - std::pair rval{false, nullptr}; + std::pair rval{false, nullptr}; if ( l ) { @@ -653,8 +654,8 @@ Manager::HookCallFunction(const zeek::Func* func, zeek::detail::Frame* parent, } } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_CALL_FUNCTION, args, + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_CALL_FUNCTION, args, HookArgument(std::make_pair(rval.first, rval.second.get()))); return rval; @@ -664,13 +665,13 @@ bool Manager::HookQueueEvent(Event* event) const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(event)); - MetaHookPre(zeek::plugin::HOOK_QUEUE_EVENT, args); + MetaHookPre(HOOK_QUEUE_EVENT, args); } - hook_list* l = hooks[zeek::plugin::HOOK_QUEUE_EVENT]; + hook_list* l = hooks[HOOK_QUEUE_EVENT]; bool result = false; @@ -686,8 +687,8 @@ bool Manager::HookQueueEvent(Event* event) const } } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_QUEUE_EVENT, args, HookArgument(result)); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_QUEUE_EVENT, args, HookArgument(result)); return result; } @@ -696,10 +697,10 @@ void Manager::HookDrainEvents() const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) - MetaHookPre(zeek::plugin::HOOK_DRAIN_EVENTS, args); + if ( HavePluginForHook(META_HOOK_PRE) ) + MetaHookPre(HOOK_DRAIN_EVENTS, args); - hook_list* l = hooks[zeek::plugin::HOOK_DRAIN_EVENTS]; + hook_list* l = hooks[HOOK_DRAIN_EVENTS]; if ( l ) for ( hook_list::iterator i = l->begin(); i != l->end(); ++i ) @@ -708,8 +709,8 @@ void Manager::HookDrainEvents() const p->HookDrainEvents(); } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_DRAIN_EVENTS, args, HookArgument()); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_DRAIN_EVENTS, args, HookArgument()); } @@ -717,13 +718,13 @@ void Manager::HookSetupAnalyzerTree(Connection *conn) const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(conn)); - MetaHookPre(zeek::plugin::HOOK_SETUP_ANALYZER_TREE, args); + MetaHookPre(HOOK_SETUP_ANALYZER_TREE, args); } - hook_list *l = hooks[zeek::plugin::HOOK_SETUP_ANALYZER_TREE]; + hook_list *l = hooks[HOOK_SETUP_ANALYZER_TREE]; if ( l ) { @@ -734,9 +735,9 @@ void Manager::HookSetupAnalyzerTree(Connection *conn) const } } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) + if ( HavePluginForHook(META_HOOK_POST) ) { - MetaHookPost(zeek::plugin::HOOK_SETUP_ANALYZER_TREE, args, HookArgument()); + MetaHookPost(HOOK_SETUP_ANALYZER_TREE, args, HookArgument()); } } @@ -744,13 +745,13 @@ void Manager::HookUpdateNetworkTime(double network_time) const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(network_time)); - MetaHookPre(zeek::plugin::HOOK_UPDATE_NETWORK_TIME, args); + MetaHookPre(HOOK_UPDATE_NETWORK_TIME, args); } - hook_list* l = hooks[zeek::plugin::HOOK_UPDATE_NETWORK_TIME]; + hook_list* l = hooks[HOOK_UPDATE_NETWORK_TIME]; if ( l ) for ( hook_list::iterator i = l->begin(); i != l->end(); ++i ) @@ -759,21 +760,21 @@ void Manager::HookUpdateNetworkTime(double network_time) const p->HookUpdateNetworkTime(network_time); } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_UPDATE_NETWORK_TIME, args, HookArgument()); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_UPDATE_NETWORK_TIME, args, HookArgument()); } void Manager::HookBroObjDtor(void* obj) const { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(obj)); - MetaHookPre(zeek::plugin::HOOK_BRO_OBJ_DTOR, args); + MetaHookPre(HOOK_BRO_OBJ_DTOR, args); } - hook_list* l = hooks[zeek::plugin::HOOK_BRO_OBJ_DTOR]; + hook_list* l = hooks[HOOK_BRO_OBJ_DTOR]; if ( l ) for ( hook_list::iterator i = l->begin(); i != l->end(); ++i ) @@ -782,8 +783,8 @@ void Manager::HookBroObjDtor(void* obj) const p->HookBroObjDtor(obj); } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_BRO_OBJ_DTOR, args, HookArgument()); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_BRO_OBJ_DTOR, args, HookArgument()); } void Manager::HookLogInit(const std::string& writer, @@ -795,7 +796,7 @@ void Manager::HookLogInit(const std::string& writer, { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(writer)); args.push_back(HookArgument(instantiating_filter)); @@ -804,10 +805,10 @@ void Manager::HookLogInit(const std::string& writer, args.push_back(HookArgument(&info)); args.push_back(HookArgument(num_fields)); args.push_back(HookArgument(std::make_pair(num_fields, fields))); - MetaHookPre(zeek::plugin::HOOK_LOG_INIT, args); + MetaHookPre(HOOK_LOG_INIT, args); } - hook_list* l = hooks[zeek::plugin::HOOK_LOG_INIT]; + hook_list* l = hooks[HOOK_LOG_INIT]; if ( l ) for ( hook_list::iterator i = l->begin(); i != l->end(); ++i ) @@ -817,8 +818,8 @@ void Manager::HookLogInit(const std::string& writer, num_fields, fields); } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_LOG_INIT, args, HookArgument()); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_LOG_INIT, args, HookArgument()); } bool Manager::HookLogWrite(const std::string& writer, @@ -830,7 +831,7 @@ bool Manager::HookLogWrite(const std::string& writer, { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(writer)); args.push_back(HookArgument(filter)); @@ -838,10 +839,10 @@ bool Manager::HookLogWrite(const std::string& writer, args.push_back(HookArgument(num_fields)); args.push_back(HookArgument(std::make_pair(num_fields, fields))); args.push_back(HookArgument(vals)); - MetaHookPre(zeek::plugin::HOOK_LOG_WRITE, args); + MetaHookPre(HOOK_LOG_WRITE, args); } - hook_list* l = hooks[zeek::plugin::HOOK_LOG_WRITE]; + hook_list* l = hooks[HOOK_LOG_WRITE]; bool result = true; @@ -858,14 +859,14 @@ bool Manager::HookLogWrite(const std::string& writer, } } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_LOG_WRITE, args, HookArgument(result)); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_LOG_WRITE, args, HookArgument(result)); return result; } bool Manager::HookReporter(const std::string& prefix, const EventHandlerPtr event, - const zeek::Connection* conn, const ValPList* addl, bool location, + const Connection* conn, const ValPList* addl, bool location, const zeek::detail::Location* location1, const zeek::detail::Location* location2, bool time, const std::string& message) @@ -873,7 +874,7 @@ bool Manager::HookReporter(const std::string& prefix, const EventHandlerPtr even { HookArgumentList args; - if ( HavePluginForHook(zeek::plugin::META_HOOK_PRE) ) + if ( HavePluginForHook(META_HOOK_PRE) ) { args.push_back(HookArgument(prefix)); args.push_back(HookArgument(conn)); @@ -883,10 +884,10 @@ bool Manager::HookReporter(const std::string& prefix, const EventHandlerPtr even args.push_back(HookArgument(location)); args.push_back(HookArgument(time)); args.push_back(HookArgument(message)); - MetaHookPre(zeek::plugin::HOOK_REPORTER, args); + MetaHookPre(HOOK_REPORTER, args); } - hook_list* l = hooks[zeek::plugin::HOOK_REPORTER]; + hook_list* l = hooks[HOOK_REPORTER]; bool result = true; @@ -904,23 +905,25 @@ bool Manager::HookReporter(const std::string& prefix, const EventHandlerPtr even } } - if ( HavePluginForHook(zeek::plugin::META_HOOK_POST) ) - MetaHookPost(zeek::plugin::HOOK_REPORTER, args, HookArgument(result)); + if ( HavePluginForHook(META_HOOK_POST) ) + MetaHookPost(HOOK_REPORTER, args, HookArgument(result)); return result; } -void Manager::MetaHookPre(zeek::plugin::HookType hook, const HookArgumentList& args) const +void Manager::MetaHookPre(HookType hook, const HookArgumentList& args) const { - if ( hook_list* l = hooks[zeek::plugin::HOOK_CALL_FUNCTION] ) + if ( hook_list* l = hooks[HOOK_CALL_FUNCTION] ) for ( const auto& [hook_type, plugin] : *l ) plugin->MetaHookPre(hook, args); } -void Manager::MetaHookPost(zeek::plugin::HookType hook, const HookArgumentList& args, HookArgument result) const +void Manager::MetaHookPost(HookType hook, const HookArgumentList& args, HookArgument result) const { - if ( hook_list* l = hooks[zeek::plugin::HOOK_CALL_FUNCTION] ) + if ( hook_list* l = hooks[HOOK_CALL_FUNCTION] ) for ( const auto& [hook_type, plugin] : *l ) plugin->MetaHookPost(hook, args, result); } + +} // namespace zeek::plugin diff --git a/src/plugin/Manager.h b/src/plugin/Manager.h index b448cd1bab..4c9cf49449 100644 --- a/src/plugin/Manager.h +++ b/src/plugin/Manager.h @@ -166,7 +166,7 @@ public: * * @return True if there's a plugin for that hook. */ - bool HavePluginForHook(zeek::plugin::HookType hook) const + bool HavePluginForHook(HookType hook) const { // Inline to avoid the function call. return hooks[hook] != nullptr; @@ -178,7 +178,7 @@ public: * * @param plugin The plugin to return the hooks for. */ - std::list > HooksEnabledForPlugin(const Plugin* plugin) const; + std::list > HooksEnabledForPlugin(const Plugin* plugin) const; /** * Enables a hook for a given plugin. @@ -189,7 +189,7 @@ public: * * prio: The priority to associate with the plugin for this hook. */ - void EnableHook(zeek::plugin::HookType hook, Plugin* plugin, int prio); + void EnableHook(HookType hook, Plugin* plugin, int prio); /** * Disables a hook for a given plugin. @@ -198,7 +198,7 @@ public: * * plugin: The plugin that used to define the hook. */ - void DisableHook(zeek::plugin::HookType hook, Plugin* plugin); + void DisableHook(HookType hook, Plugin* plugin); /** * Registers interest in an event by a plugin, even if there's no handler @@ -257,7 +257,7 @@ public: * the method returns null. */ std::pair - HookCallFunction(const zeek::Func* func, zeek::detail::Frame* parent, zeek::Args* args) const; + HookCallFunction(const Func* func, zeek::detail::Frame* parent, Args* args) const; /** * Hook that filters the queuing of an event. @@ -416,8 +416,8 @@ public: private: bool ActivateDynamicPluginInternal(const std::string& name, bool ok_if_not_found = false); void UpdateInputFiles(); - void MetaHookPre(zeek::plugin::HookType hook, const HookArgumentList& args) const; - void MetaHookPost(zeek::plugin::HookType hook, const HookArgumentList& args, HookArgument result) const; + void MetaHookPre(HookType hook, const HookArgumentList& args) const; + void MetaHookPost(HookType hook, const HookArgumentList& args, HookArgument result) const; // All found dynamic plugins, mapping their names to base directory. using dynamic_plugin_map = std::map; @@ -488,16 +488,16 @@ namespace detail { */ class __RegisterBif { public: - __RegisterBif(const char* plugin, zeek::plugin::Manager::bif_init_func init) + __RegisterBif(const char* plugin, Manager::bif_init_func init) { - zeek::plugin::Manager::RegisterBifFile(plugin, init); + Manager::RegisterBifFile(plugin, init); } }; } // namespace detail } // namespace plugin -extern zeek::plugin::Manager* plugin_mgr; +extern plugin::Manager* plugin_mgr; } // namespace zeek diff --git a/src/plugin/Plugin.cc b/src/plugin/Plugin.cc index 0dd8eda839..86220803a1 100644 --- a/src/plugin/Plugin.cc +++ b/src/plugin/Plugin.cc @@ -17,11 +17,11 @@ #include "../input.h" #include "threading/SerialTypes.h" -using namespace zeek::plugin; +namespace zeek::plugin { -const char* zeek::plugin::hook_name(zeek::plugin::HookType h) +const char* hook_name(HookType h) { -static constexpr const char* hook_names[int(zeek::plugin::NUM_HOOKS) + 1] = { +static constexpr const char* hook_names[int(NUM_HOOKS) + 1] = { // Order must match that of HookType. "LoadFile", "CallFunction", @@ -69,7 +69,7 @@ BifItem::~BifItem() { } -void HookArgument::Describe(zeek::ODesc* d) const +void HookArgument::Describe(ODesc* d) const { switch ( type ) { case BOOL: @@ -319,7 +319,7 @@ Plugin::component_list Plugin::Components() const return components; } -static bool component_cmp(const zeek::plugin::Component* a, const zeek::plugin::Component* b) +static bool component_cmp(const Component* a, const Component* b) { return a->Name() < b->Name(); } @@ -336,7 +336,7 @@ void Plugin::AddBifItem(const std::string& name, BifItem::Type type) bif_items.push_back(bi); } -void Plugin::AddComponent(zeek::plugin::Component* c) +void Plugin::AddComponent(Component* c) { components.push_back(c); @@ -347,27 +347,27 @@ void Plugin::AddComponent(zeek::plugin::Component* c) Plugin::hook_list Plugin::EnabledHooks() const { - return zeek::plugin_mgr->HooksEnabledForPlugin(this); + return plugin_mgr->HooksEnabledForPlugin(this); } -void Plugin::EnableHook(zeek::plugin::HookType hook, int priority) +void Plugin::EnableHook(HookType hook, int priority) { - zeek::plugin_mgr->EnableHook(hook, this, priority); + plugin_mgr->EnableHook(hook, this, priority); } -void Plugin::DisableHook(zeek::plugin::HookType hook) +void Plugin::DisableHook(HookType hook) { - zeek::plugin_mgr->DisableHook(hook, this); + plugin_mgr->DisableHook(hook, this); } void Plugin::RequestEvent(EventHandlerPtr handler) { - zeek::plugin_mgr->RequestEvent(handler, this); + plugin_mgr->RequestEvent(handler, this); } void Plugin::RequestBroObjDtor(Obj* obj) { - zeek::plugin_mgr->RequestBroObjDtor(obj, this); + plugin_mgr->RequestBroObjDtor(obj, this); } int Plugin::HookLoadFile(const LoadType type, const std::string& file, const std::string& resolved) @@ -375,9 +375,9 @@ int Plugin::HookLoadFile(const LoadType type, const std::string& file, const std return -1; } -std::pair -Plugin::HookFunctionCall(const zeek::Func* func, zeek::detail::Frame* parent, - zeek::Args* args) +std::pair +Plugin::HookFunctionCall(const Func* func, zeek::detail::Frame* parent, + Args* args) { ValPList vlargs(args->size()); @@ -390,15 +390,15 @@ Plugin::HookFunctionCall(const zeek::Func* func, zeek::detail::Frame* parent, #pragma GCC diagnostic pop for ( auto i = 0u; i < args->size(); ++i ) - (*args)[i] = {zeek::AdoptRef{}, vlargs[i]}; + (*args)[i] = {AdoptRef{}, vlargs[i]}; - return {handled, {zeek::AdoptRef{}, result}}; + return {handled, {AdoptRef{}, result}}; } -std::pair Plugin::HookCallFunction( - const zeek::Func* func, zeek::detail::Frame *parent, ValPList* args) +std::pair Plugin::HookCallFunction( + const Func* func, zeek::detail::Frame *parent, ValPList* args) { - std::pair result(false, NULL); + std::pair result(false, NULL); return result; } @@ -448,11 +448,11 @@ bool Plugin::HookReporter(const std::string& prefix, const EventHandlerPtr event return true; } -void Plugin::MetaHookPre(zeek::plugin::HookType hook, const HookArgumentList& args) +void Plugin::MetaHookPre(HookType hook, const HookArgumentList& args) { } -void Plugin::MetaHookPost(zeek::plugin::HookType hook, const HookArgumentList& args, HookArgument result) +void Plugin::MetaHookPost(HookType hook, const HookArgumentList& args, HookArgument result) { } @@ -462,7 +462,7 @@ void Plugin::InitializeComponents() (*i)->Initialize(); } -void Plugin::Describe(zeek::ODesc* d) const +void Plugin::Describe(ODesc* d) const { d->Add(config.name); @@ -557,3 +557,5 @@ void Plugin::Describe(zeek::ODesc* d) const d->Add(")\n"); } } + +} // namespace zeek::plugin diff --git a/src/plugin/Plugin.h b/src/plugin/Plugin.h index d2002df1d7..a81a124d61 100644 --- a/src/plugin/Plugin.h +++ b/src/plugin/Plugin.h @@ -30,7 +30,7 @@ namespace threading { namespace zeek { template class IntrusivePtr; -using ValPtr = zeek::IntrusivePtr; +using ValPtr = IntrusivePtr; class Obj; } @@ -70,7 +70,7 @@ enum HookType { /** * Converts a hook type into a readable hook name. */ -extern const char* hook_name(zeek::plugin::HookType h); +extern const char* hook_name(HookType h); /** * Helper class to capture a plugin's version. @@ -206,7 +206,7 @@ public: /** * Constructor with a function argument. */ - explicit HookArgument(const zeek::Func* a) { type = FUNC; arg.func = a; } + explicit HookArgument(const Func* a) { type = FUNC; arg.func = a; } /** * Constructor with an integer argument. @@ -241,7 +241,7 @@ public: /** * Constructor with a Frame argument. */ - explicit HookArgument(zeek::detail::Frame* f) { type = FRAME; arg.frame = f; } + explicit HookArgument(detail::Frame* f) { type = FRAME; arg.frame = f; } /** * Constructor with a WriterInfo argument. @@ -261,7 +261,7 @@ public: /** * Constructor with a zeek::Args argument. */ - explicit HookArgument(const zeek::Args* args) { type = ARG_LIST; arg.args = args; } + explicit HookArgument(const Args* args) { type = ARG_LIST; arg.args = args; } /** * Returns the value for a boolen argument. The argument's type must @@ -291,7 +291,7 @@ public: * Returns the value for a function argument. The argument's type must * match accordingly. */ - const zeek::Func* AsFunc() const { assert(type == FUNC); return arg.func; } + const Func* AsFunc() const { assert(type == FUNC); return arg.func; } /** * Returns the value for an integer argument. The argument's type must @@ -342,9 +342,9 @@ public: const ValPList* AsValList() const { assert(type == VAL_LIST); return arg.vals; } /** - * Returns the value as a zeek::Args. + * Returns the value as a Args. */ - const zeek::Args* AsArgList() const { assert(type == ARG_LIST); return arg.args; } + const Args* AsArgList() const { assert(type == ARG_LIST); return arg.args; } /** * Returns the value for a vod pointer argument. The argument's type @@ -362,7 +362,7 @@ public: * * @param d Description object to use for rendering. */ - void Describe(zeek::ODesc* d) const; + void Describe(ODesc* d) const; private: Type type; @@ -371,15 +371,15 @@ private: double double_; const Event* event; const Connection* conn; - const zeek::Func* func; - const zeek::detail::Frame* frame; + const Func* func; + const detail::Frame* frame; int int_; const Val* val; const ValPList* vals; - const zeek::Args* args; + const Args* args; const void* voidp; const logging::WriterBackend::WriterInfo* winfo; - const zeek::detail::Location* loc; + const detail::Location* loc; } arg; // Outside union because these have dtors. @@ -419,7 +419,7 @@ using HookArgumentList = std::list; */ class Plugin { public: - typedef std::list component_list; + typedef std::list component_list; typedef std::list bif_item_list; typedef std::list > hook_list; @@ -493,7 +493,7 @@ public: * is disabled, the rendering will include a list of all components * and BiF items. */ - void Describe(zeek::ODesc* d) const; + void Describe(ODesc* d) const; /** * Registers an individual BiF that the plugin defines. The @@ -534,7 +534,7 @@ public: bool LoadBroFile(const std::string& file); protected: - friend class zeek::plugin::Manager; + friend class Manager; /** * First-stage initialization of the plugin called early during Bro's @@ -564,7 +564,7 @@ protected: * * @param c The component. The method takes ownership. */ - void AddComponent(zeek::plugin::Component* c); + void AddComponent(Component* c); /** * Calls the Initialize() function of all components. @@ -590,7 +590,7 @@ protected: * highest to lowest. If two plugins specify the same priority, order * is undefined. */ - void EnableHook(zeek::plugin::HookType hook, int priority = 0); + void EnableHook(HookType hook, int priority = 0); /** * Disables a hook. Bro will no longer call the corresponding virtual @@ -598,7 +598,7 @@ protected: * * @param hook The hook to disable. */ - void DisableHook(zeek::plugin::HookType hook); + void DisableHook(HookType hook); /** * Returns a list of hooks that are currently enabled for the plugin, @@ -626,7 +626,7 @@ protected: * * @param handler The object being interested in. */ - void RequestBroObjDtor(zeek::Obj* obj); + void RequestBroObjDtor(Obj* obj); // Hook functions. @@ -679,10 +679,10 @@ protected: * pair with the first member set to 'false' and null result value. */ virtual std::pair - HookFunctionCall(const zeek::Func* func, zeek::detail::Frame* parent, zeek::Args* args); + HookFunctionCall(const Func* func, zeek::detail::Frame* parent, Args* args); [[deprecated("Remove in v4.1. Use HookFunctionCall()")]] - virtual std::pair HookCallFunction(const zeek::Func* func, zeek::detail::Frame *parent, ValPList* args); + virtual std::pair HookCallFunction(const Func* func, zeek::detail::Frame *parent, ValPList* args); /** * Hook into raising events. Whenever the script interpreter is about @@ -838,8 +838,8 @@ protected: bool time, const std::string& message); // Meta hooks. - virtual void MetaHookPre(zeek::plugin::HookType hook, const HookArgumentList& args); - virtual void MetaHookPost(zeek::plugin::HookType hook, const HookArgumentList& args, HookArgument result); + virtual void MetaHookPre(HookType hook, const HookArgumentList& args); + virtual void MetaHookPost(HookType hook, const HookArgumentList& args, HookArgument result); private: diff --git a/src/probabilistic/BloomFilter.cc b/src/probabilistic/BloomFilter.cc index 3ef3ee06e2..444f05325e 100644 --- a/src/probabilistic/BloomFilter.cc +++ b/src/probabilistic/BloomFilter.cc @@ -110,13 +110,13 @@ bool BasicBloomFilter::Merge(const BloomFilter* other) if ( ! hasher->Equals(o->hasher) ) { - zeek::reporter->Error("incompatible hashers in BasicBloomFilter merge"); + reporter->Error("incompatible hashers in BasicBloomFilter merge"); return false; } else if ( bits->Size() != o->bits->Size() ) { - zeek::reporter->Error("different bitvector size in BasicBloomFilter merge"); + reporter->Error("different bitvector size in BasicBloomFilter merge"); return false; } @@ -137,7 +137,7 @@ BasicBloomFilter* BasicBloomFilter::Clone() const std::string BasicBloomFilter::InternalState() const { - return zeek::util::fmt("%" PRIu64, bits->Hash()); + return util::fmt("%" PRIu64, bits->Hash()); } BasicBloomFilter::BasicBloomFilter() @@ -229,13 +229,13 @@ bool CountingBloomFilter::Merge(const BloomFilter* other) if ( ! hasher->Equals(o->hasher) ) { - zeek::reporter->Error("incompatible hashers in CountingBloomFilter merge"); + reporter->Error("incompatible hashers in CountingBloomFilter merge"); return false; } else if ( cells->Size() != o->cells->Size() ) { - zeek::reporter->Error("different bitvector size in CountingBloomFilter merge"); + reporter->Error("different bitvector size in CountingBloomFilter merge"); return false; } @@ -256,7 +256,7 @@ CountingBloomFilter* CountingBloomFilter::Clone() const std::string CountingBloomFilter::InternalState() const { - return zeek::util::fmt("%" PRIu64, cells->Hash()); + return util::fmt("%" PRIu64, cells->Hash()); } // TODO: Use partitioning in add/count to allow for reusing CMS bounds. diff --git a/src/probabilistic/CardinalityCounter.cc b/src/probabilistic/CardinalityCounter.cc index db2fa85936..53f13da938 100644 --- a/src/probabilistic/CardinalityCounter.cc +++ b/src/probabilistic/CardinalityCounter.cc @@ -50,11 +50,11 @@ void CardinalityCounter::Init(uint64_t size) alpha_m = 0.7213 / (1 + 1.079 / m); else - zeek::reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be 16, 32, 64 or bigger than 128", size); + reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be 16, 32, 64 or bigger than 128", size); double calc_p = log2(m); if ( trunc(calc_p) != calc_p ) - zeek::reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be a power of 2", size); + reporter->InternalError("Invalid size %" PRIu64 ". Size either has to be a power of 2", size); p = calc_p; diff --git a/src/probabilistic/Hasher.cc b/src/probabilistic/Hasher.cc index 06062a479c..1abfb4ea27 100644 --- a/src/probabilistic/Hasher.cc +++ b/src/probabilistic/Hasher.cc @@ -23,7 +23,7 @@ Hasher::seed_t Hasher::MakeSeed(const void* data, size_t size) assert(sizeof(tmpseed) == 16); - static auto global_hash_seed = zeek::id::find_val("global_hash_seed"); + static auto global_hash_seed = id::find_val("global_hash_seed"); if ( data ) zeek::detail::hash_update(ctx, data, size); @@ -33,7 +33,7 @@ Hasher::seed_t Hasher::MakeSeed(const void* data, size_t size) else { - unsigned int first_seed = zeek::util::detail::initial_seed(); + unsigned int first_seed = util::detail::initial_seed(); zeek::detail::hash_update(ctx, &first_seed, sizeof(first_seed)); } @@ -119,7 +119,7 @@ DefaultHasher::DefaultHasher(size_t k, Hasher::seed_t seed) for ( size_t i = 1; i <= k; ++i ) { seed_t s = Seed(); - s.h[0] += zeek::util::detail::prng(i); + s.h[0] += util::detail::prng(i); hash_functions.push_back(UHF(s)); } } @@ -149,7 +149,7 @@ bool DefaultHasher::Equals(const Hasher* other) const } DoubleHasher::DoubleHasher(size_t k, seed_t seed) - : Hasher(k, seed), h1(seed + zeek::util::detail::prng(1)), h2(seed + zeek::util::detail::prng(2)) + : Hasher(k, seed), h1(seed + util::detail::prng(1)), h2(seed + util::detail::prng(2)) { } diff --git a/src/probabilistic/Topk.cc b/src/probabilistic/Topk.cc index fa35a7da6f..8cd831e8c4 100644 --- a/src/probabilistic/Topk.cc +++ b/src/probabilistic/Topk.cc @@ -17,11 +17,11 @@ static void topk_element_hash_delete_func(void* val) delete e; } -void TopkVal::Typify(zeek::TypePtr t) +void TopkVal::Typify(TypePtr t) { assert(!hash && !type); type = std::move(t); - auto tl = zeek::make_intrusive(type); + auto tl = make_intrusive(type); tl->Append(type); hash = new zeek::detail::CompositeHash(std::move(tl)); } @@ -35,7 +35,7 @@ zeek::detail::HashKey* TopkVal::GetHash(Val* v) const TopkVal::TopkVal(uint64_t arg_size) : OpaqueVal(topk_type) { - elementDict = new zeek::PDict; + elementDict = new PDict; elementDict->SetDeleteFunc(topk_element_hash_delete_func); size = arg_size; numElements = 0; @@ -45,7 +45,7 @@ TopkVal::TopkVal(uint64_t arg_size) : OpaqueVal(topk_type) TopkVal::TopkVal() : OpaqueVal(topk_type) { - elementDict = new zeek::PDict; + elementDict = new PDict; elementDict->SetDeleteFunc(topk_element_hash_delete_func); size = 0; numElements = 0; @@ -87,7 +87,7 @@ void TopkVal::Merge(const TopkVal* value, bool doPrune) { if ( ! same_type(type, value->type) ) { - zeek::reporter->Error("Cannot merge top-k elements of differing types."); + reporter->Error("Cannot merge top-k elements of differing types."); return; } } @@ -175,23 +175,23 @@ void TopkVal::Merge(const TopkVal* value, bool doPrune) } } -zeek::ValPtr TopkVal::DoClone(CloneState* state) +ValPtr TopkVal::DoClone(CloneState* state) { - auto clone = zeek::make_intrusive(size); + auto clone = make_intrusive(size); clone->Merge(this); return state->NewClone(this, std::move(clone)); } -zeek::VectorValPtr TopkVal::GetTopK(int k) const // returns vector +VectorValPtr TopkVal::GetTopK(int k) const // returns vector { if ( numElements == 0 ) { - zeek::reporter->Error("Cannot return topk of empty"); + reporter->Error("Cannot return topk of empty"); return nullptr; } - auto v = zeek::make_intrusive(type); - auto t = zeek::make_intrusive(std::move(v)); + auto v = make_intrusive(type); + auto t = make_intrusive(std::move(v)); // this does no estimation if the results is correct! // in any case - just to make this future-proof (and I am lazy) - this can return more than k. @@ -228,7 +228,7 @@ uint64_t TopkVal::GetCount(Val* value) const if ( e == nullptr ) { - zeek::reporter->Error("GetCount for element that is not in top-k"); + reporter->Error("GetCount for element that is not in top-k"); return 0; } @@ -243,7 +243,7 @@ uint64_t TopkVal::GetEpsilon(Val* value) const if ( e == nullptr ) { - zeek::reporter->Error("GetEpsilon for element that is not in top-k"); + reporter->Error("GetEpsilon for element that is not in top-k"); return 0; } @@ -263,12 +263,12 @@ uint64_t TopkVal::GetSum() const } if ( pruned ) - zeek::reporter->Warning("TopkVal::GetSum() was used on a pruned data structure. Result values do not represent total element count"); + reporter->Warning("TopkVal::GetSum() was used on a pruned data structure. Result values do not represent total element count"); return sum; } -void TopkVal::Encountered(zeek::ValPtr encountered) +void TopkVal::Encountered(ValPtr encountered) { // ok, let's see if we already know this one. @@ -277,7 +277,7 @@ void TopkVal::Encountered(zeek::ValPtr encountered) else if ( ! same_type(type, encountered->GetType()) ) { - zeek::reporter->Error("Trying to add element to topk with differing type from other elements"); + reporter->Error("Trying to add element to topk with differing type from other elements"); return; } @@ -429,7 +429,7 @@ broker::expected TopkVal::DoSerialize() const { Element* element = *eit; d.emplace_back(element->epsilon); - auto v = zeek::Broker::detail::val_to_data(element->value.get()); + auto v = Broker::detail::val_to_data(element->value.get()); if ( ! v ) return broker::ec::invalid_data; @@ -494,7 +494,7 @@ bool TopkVal::DoUnserialize(const broker::data& data) for ( uint64_t j = 0; j < *elements_count; j++ ) { auto epsilon = caf::get_if(&(*v)[idx++]); - auto val = zeek::Broker::detail::data_to_val((*v)[idx++], type.get()); + auto val = Broker::detail::data_to_val((*v)[idx++], type.get()); if ( ! (epsilon && val) ) return false; diff --git a/src/probabilistic/Topk.h b/src/probabilistic/Topk.h index 00f3f7a950..df2e6531fa 100644 --- a/src/probabilistic/Topk.h +++ b/src/probabilistic/Topk.h @@ -27,11 +27,11 @@ struct Bucket { struct Element { uint64_t epsilon; - zeek::ValPtr value; + ValPtr value; Bucket* parent; }; -class TopkVal : public zeek::OpaqueVal { +class TopkVal : public OpaqueVal { public: /** @@ -55,7 +55,7 @@ public: * * @param value The encountered element */ - void Encountered(zeek::ValPtr value); + void Encountered(ValPtr value); /** * Get the first *k* elements of the result vector. At the moment, @@ -66,7 +66,7 @@ public: * * @returns The top-k encountered elements */ - zeek::VectorValPtr GetTopK(int k) const; + VectorValPtr GetTopK(int k) const; /** * Get the current count tracked in the top-k data structure for a @@ -125,7 +125,7 @@ public: * * @returns cloned TopkVal */ - zeek::ValPtr DoClone(CloneState* state) override; + ValPtr DoClone(CloneState* state) override; DECLARE_OPAQUE_VALUE(TopkVal) @@ -153,7 +153,7 @@ private: * @returns HashKey for value */ zeek::detail::HashKey* GetHash(Val* v) const; // this probably should go somewhere else. - zeek::detail::HashKey* GetHash(const zeek::ValPtr& v) const + zeek::detail::HashKey* GetHash(const ValPtr& v) const { return GetHash(v.get()); } /** @@ -161,12 +161,12 @@ private: * * @param t type that is tracked */ - void Typify(zeek::TypePtr t); + void Typify(TypePtr t); - zeek::TypePtr type; + TypePtr type; zeek::detail::CompositeHash* hash; std::list buckets; - zeek::PDict* elementDict; + PDict* elementDict; uint64_t size; // how many elements are we tracking? uint64_t numElements; // how many elements do we have at the moment bool pruned; // was this data structure pruned? diff --git a/src/supervisor/Supervisor.cc b/src/supervisor/Supervisor.cc index 9933f7af12..e03131576f 100644 --- a/src/supervisor/Supervisor.cc +++ b/src/supervisor/Supervisor.cc @@ -61,7 +61,7 @@ struct Stem { /** * Bidirectional pipes that allow the Supervisor and Stem to talk. */ - std::unique_ptr pipe; + std::unique_ptr pipe; /** * The Stem's parent process ID (i.e. PID of the Supervisor). */ @@ -111,8 +111,8 @@ struct Stem { pid_t parent_pid; int last_signal = -1; - std::unique_ptr signal_flare; - std::unique_ptr pipe; + std::unique_ptr signal_flare; + std::unique_ptr pipe; std::map nodes; std::string msg_buffer; bool shutting_down = false; @@ -180,16 +180,16 @@ read_msgs(int fd, std::string* buffer, char delim) static std::string make_create_message(const Supervisor::NodeConfig& node) { auto json_str = node.ToJSON(); - return zeek::util::fmt("create %s %s", node.name.data(), json_str.data()); + return util::fmt("create %s %s", node.name.data(), json_str.data()); } -zeek::detail::ParentProcessCheckTimer::ParentProcessCheckTimer(double t, - double arg_interval) +detail::ParentProcessCheckTimer::ParentProcessCheckTimer(double t, + double arg_interval) : Timer(t, TIMER_PPID_CHECK), interval(arg_interval) { } -void zeek::detail::ParentProcessCheckTimer::Dispatch(double t, bool is_expire) +void detail::ParentProcessCheckTimer::Dispatch(double t, bool is_expire) { // Note: only simple + portable way of detecting loss of parent // process seems to be polling for change in PPID. There's platform @@ -199,11 +199,11 @@ void zeek::detail::ParentProcessCheckTimer::Dispatch(double t, bool is_expire) // Linux: prctl(PR_SET_PDEATHSIG, ...) // FreeBSD: procctl(PROC_PDEATHSIG_CTL) // Also note the Stem process has its own polling loop with similar logic. - if ( zeek::Supervisor::ThisNode()->parent_pid != getppid() ) - zeek::run_state::detail::zeek_terminate_loop("supervised node was orphaned"); + if ( Supervisor::ThisNode()->parent_pid != getppid() ) + run_state::detail::zeek_terminate_loop("supervised node was orphaned"); if ( ! is_expire ) - timer_mgr->Add(new ParentProcessCheckTimer(zeek::run_state::network_time + interval, + timer_mgr->Add(new ParentProcessCheckTimer(run_state::network_time + interval, interval)); } @@ -217,7 +217,7 @@ Supervisor::Supervisor(Supervisor::Config cfg, SupervisorStemHandle sh) stem_stderr.prefix = "[supervisor:STDERR] "; stem_stderr.stream = stderr; - DBG_LOG(zeek::DBG_SUPERVISOR, "forked stem process %d", stem_pid); + DBG_LOG(DBG_SUPERVISOR, "forked stem process %d", stem_pid); setsignal(SIGCHLD, supervisor_signal_handler); int status; @@ -251,21 +251,21 @@ Supervisor::~Supervisor() if ( ! stem_pid ) { - DBG_LOG(zeek::DBG_SUPERVISOR, "shutdown, stem process already exited"); + DBG_LOG(DBG_SUPERVISOR, "shutdown, stem process already exited"); return; } - zeek::iosource_mgr->UnregisterFd(signal_flare.FD(), this); - zeek::iosource_mgr->UnregisterFd(stem_pipe->InFD(), this); + iosource_mgr->UnregisterFd(signal_flare.FD(), this); + iosource_mgr->UnregisterFd(stem_pipe->InFD(), this); - DBG_LOG(zeek::DBG_SUPERVISOR, "shutdown, killing stem process %d", stem_pid); + DBG_LOG(DBG_SUPERVISOR, "shutdown, killing stem process %d", stem_pid); auto kill_res = kill(stem_pid, SIGTERM); if ( kill_res == -1 ) { char tmp[256]; - zeek::util::zeek_strerror_r(errno, tmp, sizeof(tmp)); + util::zeek_strerror_r(errno, tmp, sizeof(tmp)); reporter->Error("Failed to send SIGTERM to stem process: %s", tmp); } else @@ -276,7 +276,7 @@ Supervisor::~Supervisor() if ( wait_res == -1 ) { char tmp[256]; - zeek::util::zeek_strerror_r(errno, tmp, sizeof(tmp)); + util::zeek_strerror_r(errno, tmp, sizeof(tmp)); reporter->Error("Failed to wait for stem process to exit: %s", tmp); } } @@ -308,7 +308,7 @@ void Supervisor::ReapStem() if ( res == -1 ) { char tmp[256]; - zeek::util::zeek_strerror_r(errno, tmp, sizeof(tmp)); + util::zeek_strerror_r(errno, tmp, sizeof(tmp)); reporter->Error("Supervisor failed to get exit status" " of stem process: %s", tmp); return; @@ -318,12 +318,12 @@ void Supervisor::ReapStem() if ( WIFEXITED(status) ) { - DBG_LOG(zeek::DBG_SUPERVISOR, "stem process exited with status %d", + DBG_LOG(DBG_SUPERVISOR, "stem process exited with status %d", WEXITSTATUS(status)); } else if ( WIFSIGNALED(status) ) { - DBG_LOG(zeek::DBG_SUPERVISOR, "stem process terminated by signal %d", + DBG_LOG(DBG_SUPERVISOR, "stem process terminated by signal %d", WTERMSIG(status)); } else @@ -333,15 +333,15 @@ void Supervisor::ReapStem() struct ForkResult { pid_t pid; - std::unique_ptr stdout_pipe; - std::unique_ptr stderr_pipe; + std::unique_ptr stdout_pipe; + std::unique_ptr stderr_pipe; }; static ForkResult fork_with_stdio_redirect(const char* where) { - auto out = std::make_unique(FD_CLOEXEC, FD_CLOEXEC, + auto out = std::make_unique(FD_CLOEXEC, FD_CLOEXEC, O_NONBLOCK, O_NONBLOCK); - auto err = std::make_unique(FD_CLOEXEC, FD_CLOEXEC, + auto err = std::make_unique(FD_CLOEXEC, FD_CLOEXEC, O_NONBLOCK, O_NONBLOCK); auto pid = fork(); @@ -384,7 +384,7 @@ void Supervisor::HandleChildSignal() { if ( last_signal >= 0 ) { - DBG_LOG(zeek::DBG_SUPERVISOR, "Supervisor received signal %d", last_signal); + DBG_LOG(DBG_SUPERVISOR, "Supervisor received signal %d", last_signal); last_signal = -1; } @@ -394,7 +394,7 @@ void Supervisor::HandleChildSignal() { ReapStem(); - DBG_LOG(zeek::DBG_SUPERVISOR, "Supervisor processed child signal %s", + DBG_LOG(DBG_SUPERVISOR, "Supervisor processed child signal %s", stem_pid ? "(spurious)" : ""); } @@ -410,7 +410,7 @@ void Supervisor::HandleChildSignal() { stem_pid = 0; char tmp[256]; - zeek::util::zeek_strerror_r(errno, tmp, sizeof(tmp)); + util::zeek_strerror_r(errno, tmp, sizeof(tmp)); reporter->Error("failed to fork Zeek supervisor stem process: %s\n", tmp); signal_flare.Fire(); // Sleep to avoid spinning too fast in a revival-fail loop. @@ -421,7 +421,7 @@ void Supervisor::HandleChildSignal() if ( stem_pid == 0 ) { // Child stem process needs to exec() - auto stem_env = zeek::util::fmt("%d,%d,%d,%d,%d", stem_ppid, + auto stem_env = util::fmt("%d,%d,%d,%d,%d", stem_ppid, stem_pipe->In().ReadFD(), stem_pipe->In().WriteFD(), stem_pipe->Out().ReadFD(), stem_pipe->Out().WriteFD()); @@ -435,12 +435,12 @@ void Supervisor::HandleChildSignal() stem_pipe->In().UnsetFlags(FD_CLOEXEC); stem_pipe->Out().UnsetFlags(FD_CLOEXEC); - char** args = new char*[zeek::detail::zeek_argc + 1]; + char** args = new char*[detail::zeek_argc + 1]; args[0] = config.zeek_exe_path.data(); - args[zeek::detail::zeek_argc] = nullptr; + args[detail::zeek_argc] = nullptr; - for ( auto i = 1; i < zeek::detail::zeek_argc; ++i ) - args[i] = zeek::detail::zeek_argv[i]; + for ( auto i = 1; i < detail::zeek_argc; ++i ) + args[i] = detail::zeek_argv[i]; auto res = execv(config.zeek_exe_path.data(), args); fprintf(stderr, "failed to exec Zeek supervisor stem process: %s\n", @@ -449,11 +449,11 @@ void Supervisor::HandleChildSignal() } else { - if ( ! zeek::iosource_mgr->UnregisterFd(stem_stdout.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->UnregisterFd(stem_stdout.pipe->ReadFD(), this) ) reporter->FatalError("Revived supervisor stem failed to unregister " "redirected stdout pipe"); - if ( ! zeek::iosource_mgr->UnregisterFd(stem_stderr.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->UnregisterFd(stem_stderr.pipe->ReadFD(), this) ) reporter->FatalError("Revived supervisor stem failed to unregister " "redirected stderr pipe"); @@ -462,16 +462,16 @@ void Supervisor::HandleChildSignal() stem_stdout.pipe = std::move(fork_res.stdout_pipe); stem_stderr.pipe = std::move(fork_res.stderr_pipe); - if ( ! zeek::iosource_mgr->RegisterFd(stem_stdout.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->RegisterFd(stem_stdout.pipe->ReadFD(), this) ) reporter->FatalError("Revived supervisor stem failed to register " "redirected stdout pipe"); - if ( ! zeek::iosource_mgr->RegisterFd(stem_stderr.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->RegisterFd(stem_stderr.pipe->ReadFD(), this) ) reporter->FatalError("Revived supervisor stem failed to register " "redirected stderr pipe"); } - DBG_LOG(zeek::DBG_SUPERVISOR, "stem process revived, new pid: %d", stem_pid); + DBG_LOG(DBG_SUPERVISOR, "stem process revived, new pid: %d", stem_pid); // Parent supervisor process resends node configurations to recreate // the desired process hierarchy. @@ -485,7 +485,7 @@ void Supervisor::HandleChildSignal() { const auto& node = n.second; auto msg = make_create_message(node.config); - zeek::util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); + util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); } } @@ -494,18 +494,18 @@ void Supervisor::InitPostScript() stem_stdout.hook = id::find_func("Supervisor::stdout_hook"); stem_stderr.hook = id::find_func("Supervisor::stderr_hook"); - zeek::iosource_mgr->Register(this); + iosource_mgr->Register(this); - if ( ! zeek::iosource_mgr->RegisterFd(signal_flare.FD(), this) ) + if ( ! iosource_mgr->RegisterFd(signal_flare.FD(), this) ) reporter->FatalError("Supervisor stem failed to register signal_flare"); - if ( ! zeek::iosource_mgr->RegisterFd(stem_pipe->InFD(), this) ) + if ( ! iosource_mgr->RegisterFd(stem_pipe->InFD(), this) ) reporter->FatalError("Supervisor stem failed to register stem_pipe"); - if ( ! zeek::iosource_mgr->RegisterFd(stem_stdout.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->RegisterFd(stem_stdout.pipe->ReadFD(), this) ) reporter->FatalError("Supervisor stem failed to register stdout pipe"); - if ( ! zeek::iosource_mgr->RegisterFd(stem_stderr.pipe->ReadFD(), this) ) + if ( ! iosource_mgr->RegisterFd(stem_stderr.pipe->ReadFD(), this) ) reporter->FatalError("Supervisor stem failed to register stderr pipe"); } @@ -591,9 +591,9 @@ size_t Supervisor::ProcessMessages() for ( auto& msg : msgs ) { - DBG_LOG(zeek::DBG_SUPERVISOR, "read msg from Stem: %s", msg.data()); + DBG_LOG(DBG_SUPERVISOR, "read msg from Stem: %s", msg.data()); std::vector msg_tokens; - zeek::util::tokenize_string(msg, " ", &msg_tokens); + util::tokenize_string(msg, " ", &msg_tokens); const auto& type = msg_tokens[0]; if ( type == "status" ) @@ -611,7 +611,7 @@ size_t Supervisor::ProcessMessages() else if ( type == "error" ) { msg_tokens.erase(msg_tokens.begin()); - auto err_msg = zeek::util::implode_string_vector(msg_tokens, " "); + auto err_msg = util::implode_string_vector(msg_tokens, " "); reporter->Error("%s", err_msg.data()); } else @@ -622,9 +622,9 @@ size_t Supervisor::ProcessMessages() } Stem::Stem(State ss) - : parent_pid(ss.parent_pid), signal_flare(new zeek::detail::Flare()), pipe(std::move(ss.pipe)) + : parent_pid(ss.parent_pid), signal_flare(new detail::Flare()), pipe(std::move(ss.pipe)) { - zeek::util::detail::set_thread_name("zeek.stem"); + util::detail::set_thread_name("zeek.stem"); pipe->Swap(); stem = this; setsignal(SIGCHLD, stem_signal_handler); @@ -826,7 +826,7 @@ std::optional Stem::Revive() std::variant Stem::Spawn(SupervisorNode* node) { auto ppid = getpid(); - auto fork_res = fork_with_stdio_redirect(zeek::util::fmt("node %s", node->Name().data())); + auto fork_res = fork_with_stdio_redirect(util::fmt("node %s", node->Name().data())); auto node_pid = fork_res.pid; if ( node_pid == -1 ) @@ -840,7 +840,7 @@ std::variant Stem::Spawn(SupervisorNode* node) { setsignal(SIGCHLD, SIG_DFL); setsignal(SIGTERM, SIG_DFL); - zeek::util::detail::set_thread_name(zeek::util::fmt("zeek.%s", node->Name().data())); + util::detail::set_thread_name(util::fmt("zeek.%s", node->Name().data())); SupervisedNode rval; rval.config = node->config; rval.parent_pid = ppid; @@ -848,7 +848,7 @@ std::variant Stem::Spawn(SupervisorNode* node) } node->pid = node_pid; - auto prefix = zeek::util::fmt("[%s] ", node->Name().data()); + auto prefix = util::fmt("[%s] ", node->Name().data()); node->stdout_pipe.pipe = std::move(fork_res.stdout_pipe); node->stdout_pipe.prefix = prefix; node->stdout_pipe.stream = stdout; @@ -926,13 +926,13 @@ void Stem::Shutdown(int exit_code) void Stem::ReportStatus(const SupervisorNode& node) const { - std::string msg = zeek::util::fmt("status %s %d", node.Name().data(), node.pid); - zeek::util::safe_write(pipe->OutFD(), msg.data(), msg.size() + 1); + std::string msg = util::fmt("status %s %d", node.Name().data(), node.pid); + util::safe_write(pipe->OutFD(), msg.data(), msg.size() + 1); } void Stem::Log(std::string_view type, const char* format, va_list args) const { - auto raw_msg = zeek::util::vfmt(format, args); + auto raw_msg = util::vfmt(format, args); if ( getenv("ZEEK_DEBUG_STEM_STDERR") ) { @@ -944,7 +944,7 @@ void Stem::Log(std::string_view type, const char* format, va_list args) const std::string msg{type.data(), type.size()}; msg += " "; msg += raw_msg; - zeek::util::safe_write(pipe->OutFD(), msg.data(), msg.size() + 1); + util::safe_write(pipe->OutFD(), msg.data(), msg.size() + 1); } void Stem::LogDebug(const char* format, ...) const @@ -1090,7 +1090,7 @@ std::optional Stem::Poll() for ( auto& msg : msgs ) { std::vector msg_tokens; - zeek::util::tokenize_string(std::move(msg), " ", &msg_tokens, 2); + util::tokenize_string(std::move(msg), " ", &msg_tokens, 2); const auto& cmd = msg_tokens[0]; const auto& node_name = msg_tokens[1]; @@ -1153,7 +1153,7 @@ std::optional Supervisor::CreateStem(bool supervisor_mode) setlinebuf(stdout); setlinebuf(stderr); std::vector zeek_stem_nums; - zeek::util::tokenize_string(zeek_stem_env, ",", &zeek_stem_nums); + util::tokenize_string(zeek_stem_env, ",", &zeek_stem_nums); if ( zeek_stem_nums.size() != 5 ) { @@ -1169,7 +1169,7 @@ std::optional Supervisor::CreateStem(bool supervisor_mode) fds[i] = std::stoi(zeek_stem_nums[i + 1]); Stem::State ss; - ss.pipe = std::make_unique(FD_CLOEXEC, O_NONBLOCK, fds); + ss.pipe = std::make_unique(FD_CLOEXEC, O_NONBLOCK, fds); ss.parent_pid = stem_ppid; Stem stem{std::move(ss)}; @@ -1181,7 +1181,7 @@ std::optional Supervisor::CreateStem(bool supervisor_mode) return {}; Stem::State ss; - ss.pipe = std::make_unique(FD_CLOEXEC, O_NONBLOCK); + ss.pipe = std::make_unique(FD_CLOEXEC, O_NONBLOCK); ss.parent_pid = getpid(); auto fork_res = fork_with_stdio_redirect("stem"); auto pid = fork_res.pid; @@ -1262,7 +1262,7 @@ Supervisor::NodeConfig Supervisor::NodeConfig::FromRecord(const RecordVal* node) auto cluster_table_val = node->GetField("cluster")->AsTableVal(); auto cluster_table = cluster_table_val->AsTable(); auto c = cluster_table->InitForIteration(); - zeek::detail::HashKey* k; + detail::HashKey* k; TableEntryVal* v; while ( (v = cluster_table->NextEntry(k, c)) ) @@ -1347,51 +1347,51 @@ std::string Supervisor::NodeConfig::ToJSON() const RecordValPtr Supervisor::NodeConfig::ToRecord() const { - const auto& rt = zeek::BifType::Record::Supervisor::NodeConfig; - auto rval = zeek::make_intrusive(rt); - rval->Assign(rt->FieldOffset("name"), zeek::make_intrusive(name)); + const auto& rt = BifType::Record::Supervisor::NodeConfig; + auto rval = make_intrusive(rt); + rval->Assign(rt->FieldOffset("name"), make_intrusive(name)); if ( interface ) - rval->Assign(rt->FieldOffset("interface"), zeek::make_intrusive(*interface)); + rval->Assign(rt->FieldOffset("interface"), make_intrusive(*interface)); if ( directory ) - rval->Assign(rt->FieldOffset("directory"), zeek::make_intrusive(*directory)); + rval->Assign(rt->FieldOffset("directory"), make_intrusive(*directory)); if ( stdout_file ) - rval->Assign(rt->FieldOffset("stdout_file"), zeek::make_intrusive(*stdout_file)); + rval->Assign(rt->FieldOffset("stdout_file"), make_intrusive(*stdout_file)); if ( stderr_file ) - rval->Assign(rt->FieldOffset("stderr_file"), zeek::make_intrusive(*stderr_file)); + rval->Assign(rt->FieldOffset("stderr_file"), make_intrusive(*stderr_file)); if ( cpu_affinity ) - rval->Assign(rt->FieldOffset("cpu_affinity"), zeek::val_mgr->Int(*cpu_affinity)); + rval->Assign(rt->FieldOffset("cpu_affinity"), val_mgr->Int(*cpu_affinity)); auto st = rt->GetFieldType("scripts"); - auto scripts_val = zeek::make_intrusive(std::move(st)); + auto scripts_val = make_intrusive(std::move(st)); for ( const auto& s : scripts ) - scripts_val->Assign(scripts_val->Size(), zeek::make_intrusive(s)); + scripts_val->Assign(scripts_val->Size(), make_intrusive(s)); rval->Assign(rt->FieldOffset("scripts"), std::move(scripts_val)); auto tt = rt->GetFieldType("cluster"); - auto cluster_val = zeek::make_intrusive(std::move(tt)); + auto cluster_val = make_intrusive(std::move(tt)); rval->Assign(rt->FieldOffset("cluster"), cluster_val); for ( const auto& e : cluster ) { auto& name = e.first; auto& ep = e.second; - auto key = zeek::make_intrusive(name); - const auto& ept = zeek::BifType::Record::Supervisor::ClusterEndpoint; - auto val = zeek::make_intrusive(ept); + auto key = make_intrusive(name); + const auto& ept = BifType::Record::Supervisor::ClusterEndpoint; + auto val = make_intrusive(ept); - val->Assign(ept->FieldOffset("role"), zeek::BifType::Enum::Supervisor::ClusterRole->GetEnumVal(ep.role)); - val->Assign(ept->FieldOffset("host"), zeek::make_intrusive(ep.host)); - val->Assign(ept->FieldOffset("p"), zeek::val_mgr->Port(ep.port, TRANSPORT_TCP)); + val->Assign(ept->FieldOffset("role"), BifType::Enum::Supervisor::ClusterRole->GetEnumVal(ep.role)); + val->Assign(ept->FieldOffset("host"), make_intrusive(ep.host)); + val->Assign(ept->FieldOffset("p"), val_mgr->Port(ep.port, TRANSPORT_TCP)); if ( ep.interface ) - val->Assign(ept->FieldOffset("interface"), zeek::make_intrusive(*ep.interface)); + val->Assign(ept->FieldOffset("interface"), make_intrusive(*ep.interface)); cluster_val->Assign(std::move(key), std::move(val)); } @@ -1401,13 +1401,13 @@ RecordValPtr Supervisor::NodeConfig::ToRecord() const RecordValPtr SupervisorNode::ToRecord() const { - const auto& rt = zeek::BifType::Record::Supervisor::NodeStatus; - auto rval = zeek::make_intrusive(rt); + const auto& rt = BifType::Record::Supervisor::NodeStatus; + auto rval = make_intrusive(rt); rval->Assign(rt->FieldOffset("node"), config.ToRecord()); if ( pid ) - rval->Assign(rt->FieldOffset("pid"), zeek::val_mgr->Int(pid)); + rval->Assign(rt->FieldOffset("pid"), val_mgr->Int(pid)); return rval; } @@ -1415,7 +1415,7 @@ RecordValPtr SupervisorNode::ToRecord() const static ValPtr supervisor_role_to_cluster_node_type(BifEnum::Supervisor::ClusterRole role) { - static auto node_type = zeek::id::find_type("Cluster::NodeType"); + static auto node_type = id::find_type("Cluster::NodeType"); switch ( role ) { case BifEnum::Supervisor::LOGGER: @@ -1436,9 +1436,9 @@ bool SupervisedNode::InitCluster() const if ( config.cluster.empty() ) return false; - const auto& cluster_node_type = zeek::id::find_type("Cluster::Node"); - const auto& cluster_nodes_id = zeek::id::find("Cluster::nodes"); - const auto& cluster_manager_is_logger_id = zeek::id::find("Cluster::manager_is_logger"); + const auto& cluster_node_type = id::find_type("Cluster::Node"); + const auto& cluster_nodes_id = id::find("Cluster::nodes"); + const auto& cluster_manager_is_logger_id = id::find("Cluster::manager_is_logger"); auto cluster_nodes = cluster_nodes_id->GetVal()->AsTableVal(); auto has_logger = false; std::optional manager_name; @@ -1455,30 +1455,30 @@ bool SupervisedNode::InitCluster() const { const auto& node_name = e.first; const auto& ep = e.second; - auto key = zeek::make_intrusive(node_name); - auto val = zeek::make_intrusive(cluster_node_type); + auto key = make_intrusive(node_name); + auto val = make_intrusive(cluster_node_type); auto node_type = supervisor_role_to_cluster_node_type(ep.role); val->Assign(cluster_node_type->FieldOffset("node_type"), std::move(node_type)); - val->Assign(cluster_node_type->FieldOffset("ip"), zeek::make_intrusive(ep.host)); - val->Assign(cluster_node_type->FieldOffset("p"), zeek::val_mgr->Port(ep.port, TRANSPORT_TCP)); + val->Assign(cluster_node_type->FieldOffset("ip"), make_intrusive(ep.host)); + val->Assign(cluster_node_type->FieldOffset("p"), val_mgr->Port(ep.port, TRANSPORT_TCP)); if ( ep.interface ) val->Assign(cluster_node_type->FieldOffset("interface"), - zeek::make_intrusive(*ep.interface)); + make_intrusive(*ep.interface)); if ( manager_name && ep.role != BifEnum::Supervisor::MANAGER ) val->Assign(cluster_node_type->FieldOffset("manager"), - zeek::make_intrusive(*manager_name)); + make_intrusive(*manager_name)); cluster_nodes->Assign(std::move(key), std::move(val)); } - cluster_manager_is_logger_id->SetVal(zeek::val_mgr->Bool(! has_logger)); + cluster_manager_is_logger_id->SetVal(val_mgr->Bool(! has_logger)); return true; } -void SupervisedNode::Init(zeek::Options* options) const +void SupervisedNode::Init(Options* options) const { const auto& node_name = config.name; @@ -1507,7 +1507,7 @@ void SupervisedNode::Init(zeek::Options* options) const exit(1); } - zeek::util::safe_close(fd); + util::safe_close(fd); } if ( config.stdout_file ) @@ -1524,12 +1524,12 @@ void SupervisedNode::Init(zeek::Options* options) const exit(1); } - zeek::util::safe_close(fd); + util::safe_close(fd); } if ( config.cpu_affinity ) { - auto res = zeek::set_affinity(*config.cpu_affinity); + auto res = set_affinity(*config.cpu_affinity); if ( ! res ) fprintf(stderr, "node '%s' failed to set CPU affinity: %s\n", @@ -1557,9 +1557,9 @@ void SupervisedNode::Init(zeek::Options* options) const RecordValPtr Supervisor::Status(std::string_view node_name) { - auto rval = zeek::make_intrusive(zeek::BifType::Record::Supervisor::Status); - const auto& tt = zeek::BifType::Record::Supervisor::Status->GetFieldType("nodes"); - auto node_table_val = zeek::make_intrusive(zeek::cast_intrusive(tt)); + auto rval = make_intrusive(BifType::Record::Supervisor::Status); + const auto& tt = BifType::Record::Supervisor::Status->GetFieldType("nodes"); + auto node_table_val = make_intrusive(cast_intrusive(tt)); rval->Assign(0, node_table_val); if ( node_name.empty() ) @@ -1568,7 +1568,7 @@ RecordValPtr Supervisor::Status(std::string_view node_name) { const auto& name = n.first; const auto& node = n.second; - auto key = zeek::make_intrusive(name); + auto key = make_intrusive(name); auto val = node.ToRecord(); node_table_val->Assign(std::move(key), std::move(val)); } @@ -1582,7 +1582,7 @@ RecordValPtr Supervisor::Status(std::string_view node_name) const auto& name = it->first; const auto& node = it->second; - auto key = zeek::make_intrusive(name); + auto key = make_intrusive(name); auto val = node.ToRecord(); node_table_val->Assign(std::move(key), std::move(val)); } @@ -1602,23 +1602,23 @@ std::string Supervisor::Create(const Supervisor::NodeConfig& node) return "node names must not be an empty string"; if ( node.name.find(' ') != std::string::npos ) - return zeek::util::fmt("node names must not contain spaces: '%s'", + return util::fmt("node names must not contain spaces: '%s'", node.name.data()); if ( nodes.find(node.name) != nodes.end() ) - return zeek::util::fmt("node with name '%s' already exists", node.name.data()); + return util::fmt("node with name '%s' already exists", node.name.data()); if ( node.directory ) { - auto res = zeek::util::detail::ensure_intermediate_dirs(node.directory->data()); + auto res = util::detail::ensure_intermediate_dirs(node.directory->data()); if ( ! res ) - return zeek::util::fmt("failed to create working directory %s\n", + return util::fmt("failed to create working directory %s\n", node.directory->data()); } auto msg = make_create_message(node); - zeek::util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); + util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); nodes.emplace(node.name, node); return ""; } @@ -1630,7 +1630,7 @@ bool Supervisor::Destroy(std::string_view node_name) std::stringstream ss; ss << "destroy " << name; std::string msg = ss.str(); - zeek::util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); + util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); }; if ( node_name.empty() ) @@ -1659,7 +1659,7 @@ bool Supervisor::Restart(std::string_view node_name) std::stringstream ss; ss << "restart " << name; std::string msg = ss.str(); - zeek::util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); + util::safe_write(stem_pipe->OutFD(), msg.data(), msg.size() + 1); }; if ( node_name.empty() ) diff --git a/src/supervisor/Supervisor.h b/src/supervisor/Supervisor.h index 6bf932224b..75490dd1b4 100644 --- a/src/supervisor/Supervisor.h +++ b/src/supervisor/Supervisor.h @@ -23,7 +23,6 @@ #include "Options.h" namespace zeek { - namespace detail { struct SupervisorStemHandle; @@ -39,7 +38,7 @@ struct LineBufferedPipe { * A pipe that a parent process can read from to obtain output * written by a child process. */ - std::unique_ptr pipe; + std::unique_ptr pipe; /** * A prefix to emit before data read from the pipe. */ @@ -77,6 +76,7 @@ struct LineBufferedPipe { */ FuncPtr hook; }; + } // namespace zeek::detail /** @@ -315,11 +315,11 @@ private: Config config; pid_t stem_pid; - std::unique_ptr stem_pipe; - zeek::detail::LineBufferedPipe stem_stdout; - zeek::detail::LineBufferedPipe stem_stderr; + std::unique_ptr stem_pipe; + detail::LineBufferedPipe stem_stdout; + detail::LineBufferedPipe stem_stderr; int last_signal = -1; - zeek::detail::Flare signal_flare; + detail::Flare signal_flare; NodeMap nodes; std::string msg_buffer; }; @@ -332,17 +332,17 @@ struct SupervisorStemHandle { /** * Bidirectional pipes that allow the Supervisor and Stem to talk. */ - std::unique_ptr pipe; + std::unique_ptr pipe; /** * A pipe that the Supervisor can read from to obtain * any output written to the Stem's stdout. */ - std::unique_ptr stdout_pipe; + std::unique_ptr stdout_pipe; /** * A pipe that the Supervisor can read from to obtain * any output written to the Stem's stdout. */ - std::unique_ptr stderr_pipe; + std::unique_ptr stderr_pipe; /** * The Stem's process ID. */ @@ -369,7 +369,7 @@ struct SupervisedNode { * @param options the Zeek options to extend/modify as appropriate * for the node's configuration. */ - void Init(zeek::Options* options) const; + void Init(Options* options) const; /** * The node's configuration options. @@ -443,12 +443,12 @@ struct SupervisorNode { * A pipe that the Supervisor Stem can read from to obtain * any output written to the Nodes's stdout. */ - zeek::detail::LineBufferedPipe stdout_pipe; + detail::LineBufferedPipe stdout_pipe; /** * A pipe that the Supervisor Stem can read from to obtain * any output written to the Node's stdout. */ - zeek::detail::LineBufferedPipe stderr_pipe; + detail::LineBufferedPipe stderr_pipe; }; /** diff --git a/src/threading/BasicThread.cc b/src/threading/BasicThread.cc index dcac59ead5..56187bd936 100644 --- a/src/threading/BasicThread.cc +++ b/src/threading/BasicThread.cc @@ -20,11 +20,11 @@ BasicThread::BasicThread() killed = false; buf_len = STD_FMT_BUF_LEN; - buf = (char*) zeek::util::safe_malloc(buf_len); + buf = (char*) util::safe_malloc(buf_len); strerr_buffer = nullptr; - name = zeek::util::copy_string(zeek::util::fmt("thread-%" PRIu64, ++thread_counter)); + name = util::copy_string(util::fmt("thread-%" PRIu64, ++thread_counter)); thread_mgr->AddThread(this); } @@ -41,13 +41,13 @@ BasicThread::~BasicThread() void BasicThread::SetName(const char* arg_name) { delete [] name; - name = zeek::util::copy_string(arg_name); + name = util::copy_string(arg_name); } void BasicThread::SetOSName(const char* arg_name) { static_assert(std::is_same::value, "libstdc++ doesn't use pthread_t"); - zeek::util::detail::set_thread_name(arg_name, thread.native_handle()); + util::detail::set_thread_name(arg_name, thread.native_handle()); } const char* BasicThread::Fmt(const char* format, ...) @@ -55,7 +55,7 @@ const char* BasicThread::Fmt(const char* format, ...) if ( buf_len > 10 * STD_FMT_BUF_LEN ) { // Shrink back to normal. - buf = (char*) zeek::util::safe_realloc(buf, STD_FMT_BUF_LEN); + buf = (char*) util::safe_realloc(buf, STD_FMT_BUF_LEN); buf_len = STD_FMT_BUF_LEN; } @@ -67,7 +67,7 @@ const char* BasicThread::Fmt(const char* format, ...) if ( (unsigned int) n >= buf_len ) { // Not enough room, grow the buffer. buf_len = n + 32; - buf = (char*) zeek::util::safe_realloc(buf, buf_len); + buf = (char*) util::safe_realloc(buf, buf_len); // Is it portable to restart? va_start(al, format); @@ -83,7 +83,7 @@ const char* BasicThread::Strerror(int err) if ( ! strerr_buffer ) strerr_buffer = new char[256]; - zeek::util::zeek_strerror_r(err, strerr_buffer, 256); + util::zeek_strerror_r(err, strerr_buffer, 256); return strerr_buffer; } @@ -96,7 +96,7 @@ void BasicThread::Start() thread = std::thread(&BasicThread::launcher, this); - DBG_LOG(zeek::DBG_THREADING, "Started thread %s", name); + DBG_LOG(DBG_THREADING, "Started thread %s", name); OnStart(); } @@ -109,7 +109,7 @@ void BasicThread::SignalStop() if ( terminating ) return; - DBG_LOG(zeek::DBG_THREADING, "Signaling thread %s to terminate ...", name); + DBG_LOG(DBG_THREADING, "Signaling thread %s to terminate ...", name); OnSignalStop(); } @@ -119,7 +119,7 @@ void BasicThread::WaitForStop() if ( ! started ) return; - DBG_LOG(zeek::DBG_THREADING, "Waiting for thread %s to terminate and process last queue items...", name); + DBG_LOG(DBG_THREADING, "Waiting for thread %s to terminate and process last queue items...", name); OnWaitForStop(); @@ -142,10 +142,10 @@ void BasicThread::Join() } catch ( const std::system_error& e ) { - zeek::reporter->FatalError("Failure joining thread %s with error %s", name, e.what()); + reporter->FatalError("Failure joining thread %s with error %s", name, e.what()); } - DBG_LOG(zeek::DBG_THREADING, "Joined with thread %s", name); + DBG_LOG(DBG_THREADING, "Joined with thread %s", name); } void BasicThread::Kill() @@ -160,7 +160,7 @@ void BasicThread::Kill() void BasicThread::Done() { - DBG_LOG(zeek::DBG_THREADING, "Thread %s has finished", name); + DBG_LOG(DBG_THREADING, "Thread %s has finished", name); terminating = true; killed = true; diff --git a/src/threading/Formatter.h b/src/threading/Formatter.h index ef688c6635..37b83727cc 100644 --- a/src/threading/Formatter.h +++ b/src/threading/Formatter.h @@ -26,7 +26,7 @@ public: * internal formatting. * */ - explicit Formatter(threading::MsgThread* t); + explicit Formatter(MsgThread* t); /** * Destructor. @@ -49,8 +49,8 @@ public: * @return Returns true on success, false on error. Errors must also * be flagged via the thread. */ - virtual bool Describe(zeek::ODesc* desc, int num_fields, const threading::Field* const * fields, - threading::Value** vals) const = 0; + virtual bool Describe(ODesc* desc, int num_fields, const Field* const * fields, + Value** vals) const = 0; /** * Convert a single threading value into an implementation-specific @@ -65,7 +65,7 @@ public: * @return Returns true on success, false on error. Errors are also * flagged via the thread. */ - virtual bool Describe(zeek::ODesc* desc, threading::Value* val, const std::string& name = "") const = 0; + virtual bool Describe(ODesc* desc, Value* val, const std::string& name = "") const = 0; /** * Convert an implementation-specific textual representation of a @@ -79,7 +79,8 @@ public: * @return The new value, or null on error. Errors must also be * flagged via the thread. */ - virtual threading::Value* ParseValue(const std::string& s, const std::string& name, zeek::TypeTag type, zeek::TypeTag subtype = zeek::TYPE_ERROR) const = 0; + virtual Value* ParseValue(const std::string& s, const std::string& name, TypeTag type, + TypeTag subtype = TYPE_ERROR) const = 0; /** * Convert an IP address into a string. @@ -90,7 +91,7 @@ public: * * @return An ASCII representation of the address. */ - static std::string Render(const threading::Value::addr_t& addr); + static std::string Render(const Value::addr_t& addr); /** * Convert an subnet value into a string. @@ -101,7 +102,7 @@ public: * * @return An ASCII representation of the subnet. */ - static std::string Render(const threading::Value::subnet_t& subnet); + static std::string Render(const Value::subnet_t& subnet); /** * Convert a double into a string. This renders the double with Bro's @@ -149,17 +150,17 @@ public: * @return The address, which will be all-zero on error. Errors are * also flagged via the thread. */ - threading::Value::addr_t ParseAddr(const std::string &addr) const; + Value::addr_t ParseAddr(const std::string &addr) const; protected: /** * Returns the thread associated with the formatter via the * constructor. */ - threading::MsgThread* GetThread() const { return thread; } + MsgThread* GetThread() const { return thread; } private: - threading::MsgThread* thread; + MsgThread* thread; }; } // namespace zeek::threading diff --git a/src/threading/Manager.cc b/src/threading/Manager.cc index d92c0c55e6..b1c8f70417 100644 --- a/src/threading/Manager.cc +++ b/src/threading/Manager.cc @@ -25,7 +25,7 @@ void HeartbeatTimer::Dispatch(double t, bool is_expire) Manager::Manager() { - DBG_LOG(zeek::DBG_THREADING, "Creating thread manager ..."); + DBG_LOG(DBG_THREADING, "Creating thread manager ..."); did_process = true; next_beat = 0; @@ -40,7 +40,7 @@ Manager::~Manager() void Manager::Terminate() { - DBG_LOG(zeek::DBG_THREADING, "Terminating thread manager ..."); + DBG_LOG(DBG_THREADING, "Terminating thread manager ..."); terminating = true; // First process remaining thread output for the message threads. @@ -68,7 +68,7 @@ void Manager::Terminate() void Manager::AddThread(BasicThread* thread) { - DBG_LOG(zeek::DBG_THREADING, "Adding thread %s ...", thread->Name()); + DBG_LOG(DBG_THREADING, "Adding thread %s ...", thread->Name()); all_threads.push_back(thread); if ( ! heartbeat_timer_running ) @@ -77,13 +77,13 @@ void Manager::AddThread(BasicThread* thread) void Manager::AddMsgThread(MsgThread* thread) { - DBG_LOG(zeek::DBG_THREADING, "%s is a MsgThread ...", thread->Name()); + DBG_LOG(DBG_THREADING, "%s is a MsgThread ...", thread->Name()); msg_threads.push_back(thread); } void Manager::KillThreads() { - DBG_LOG(zeek::DBG_THREADING, "Killing threads ..."); + DBG_LOG(DBG_THREADING, "Killing threads ..."); for ( all_thread_list::iterator i = all_threads.begin(); i != all_threads.end(); i++ ) (*i)->Kill(); @@ -91,7 +91,7 @@ void Manager::KillThreads() void Manager::KillThread(BasicThread* thread) { - DBG_LOG(zeek::DBG_THREADING, "Killing thread %s ...", thread->Name()); + DBG_LOG(DBG_THREADING, "Killing thread %s ...", thread->Name()); thread->Kill(); } @@ -131,7 +131,7 @@ void Manager::SendHeartbeats() void Manager::StartHeartbeatTimer() { heartbeat_timer_running = true; - zeek::detail::timer_mgr->Add(new detail::HeartbeatTimer(zeek::run_state::network_time + zeek::BifConst::Threading::heartbeat_interval)); + zeek::detail::timer_mgr->Add(new detail::HeartbeatTimer(run_state::network_time + BifConst::Threading::heartbeat_interval)); } // Raise everything in here as warnings so it is passed to scriptland without @@ -139,16 +139,16 @@ void Manager::StartHeartbeatTimer() // one reporter message. bool Manager::SendEvent(MsgThread* thread, const std::string& name, const int num_vals, Value* *vals) const { - zeek::EventHandler* handler = zeek::event_registry->Lookup(name); + EventHandler* handler = event_registry->Lookup(name); if ( handler == nullptr ) { - zeek::reporter->Warning("Thread %s: Event %s not found", thread->Name(), name.c_str()); + reporter->Warning("Thread %s: Event %s not found", thread->Name(), name.c_str()); Value::delete_value_ptr_array(vals, num_vals); return false; } #ifdef DEBUG - DBG_LOG(zeek::DBG_INPUT, "Thread %s: SendEvent for event %s with %d vals", + DBG_LOG(DBG_INPUT, "Thread %s: SendEvent for event %s with %d vals", thread->Name(), name.c_str(), num_vals); #endif @@ -156,20 +156,20 @@ bool Manager::SendEvent(MsgThread* thread, const std::string& name, const int nu int num_event_vals = type->NumFields(); if ( num_vals != num_event_vals ) { - zeek::reporter->Warning("Thread %s: Wrong number of values for event %s", thread->Name(), name.c_str()); + reporter->Warning("Thread %s: Wrong number of values for event %s", thread->Name(), name.c_str()); Value::delete_value_ptr_array(vals, num_vals); return false; } bool convert_error = false; - zeek::Args vl; + Args vl; vl.reserve(num_vals); for ( int j = 0; j < num_vals; j++) { - zeek::Val* v = Value::ValueToVal(std::string("thread ") + thread->Name(), vals[j], convert_error); - vl.emplace_back(zeek::AdoptRef{}, v); + Val* v = Value::ValueToVal(std::string("thread ") + thread->Name(), vals[j], convert_error); + vl.emplace_back(AdoptRef{}, v); if ( v && ! convert_error && ! same_type(type->GetFieldType(j), v->GetType()) ) { @@ -183,7 +183,7 @@ bool Manager::SendEvent(MsgThread* thread, const std::string& name, const int nu if ( convert_error ) return false; else if ( handler ) - zeek::event_mgr.Enqueue(handler, std::move(vl), zeek::util::detail::SOURCE_LOCAL); + event_mgr.Enqueue(handler, std::move(vl), util::detail::SOURCE_LOCAL); return true; } @@ -192,10 +192,10 @@ void Manager::Flush() { bool do_beat = false; - if ( zeek::run_state::network_time && (zeek::run_state::network_time > next_beat || ! next_beat) ) + if ( run_state::network_time && (run_state::network_time > next_beat || ! next_beat) ) { do_beat = true; - next_beat = ::zeek::run_state::network_time + zeek::BifConst::Threading::heartbeat_interval; + next_beat = run_state::network_time + BifConst::Threading::heartbeat_interval; } did_process = false; @@ -214,13 +214,13 @@ void Manager::Flush() if ( msg->Process() ) { - if ( zeek::run_state::network_time ) + if ( run_state::network_time ) did_process = true; } else { - zeek::reporter->Error("%s failed, terminating thread", msg->Name()); + reporter->Error("%s failed, terminating thread", msg->Name()); t->SignalStop(); } @@ -254,8 +254,8 @@ void Manager::Flush() delete t; } - // fprintf(stderr, "P %.6f %.6f do_beat=%d did_process=%d next_next=%.6f\n", zeek::run_state::network_time, - // zeek::detail::timer_mgr->Time(), do_beat, (int)did_process, next_beat); + // fprintf(stderr, "P %.6f %.6f do_beat=%d did_process=%d next_next=%.6f\n", run_state::network_time, + // detail::timer_mgr->Time(), do_beat, (int)did_process, next_beat); } const threading::Manager::msg_stats_list& threading::Manager::GetMsgThreadStats() diff --git a/src/threading/Manager.h b/src/threading/Manager.h index be01f72982..5ce2797862 100644 --- a/src/threading/Manager.h +++ b/src/threading/Manager.h @@ -102,7 +102,7 @@ public: * @param vals Values passed to the event * @returns True on success false on failure. */ - bool SendEvent(MsgThread* thread, const std::string& name, const int num_vals, threading::Value* *vals) const; + bool SendEvent(MsgThread* thread, const std::string& name, const int num_vals, Value* *vals) const; protected: friend class BasicThread; diff --git a/src/threading/MsgThread.cc b/src/threading/MsgThread.cc index 684c0ba774..bcce6712ee 100644 --- a/src/threading/MsgThread.cc +++ b/src/threading/MsgThread.cc @@ -78,7 +78,7 @@ public: ReporterMessage(Type arg_type, MsgThread* thread, const char* arg_msg) : OutputMessage("ReporterMessage", thread) - { type = arg_type; msg = zeek::util::copy_string(arg_msg); } + { type = arg_type; msg = util::copy_string(arg_msg); } ~ReporterMessage() override { delete [] msg; } @@ -110,9 +110,9 @@ public: class DebugMessage final : public OutputMessage { public: - DebugMessage(zeek::DebugStream arg_stream, MsgThread* thread, const char* arg_msg) + DebugMessage(DebugStream arg_stream, MsgThread* thread, const char* arg_msg) : OutputMessage("DebugMessage", thread) - { stream = arg_stream; msg = zeek::util::copy_string(arg_msg); } + { stream = arg_stream; msg = util::copy_string(arg_msg); } ~DebugMessage() override { delete [] msg; } @@ -123,7 +123,7 @@ public: } private: const char* msg; - zeek::DebugStream stream; + DebugStream stream; }; #endif @@ -132,7 +132,7 @@ class SendEventMessage final : public OutputMessage { public: SendEventMessage(MsgThread* thread, const char* name, const int num_vals, Value* *val) : OutputMessage("SendEvent", thread), - name(zeek::util::copy_string(name)), num_vals(num_vals), val(val) {} + name(util::copy_string(name)), num_vals(num_vals), val(val) {} ~SendEventMessage() override { delete [] name; } @@ -141,7 +141,7 @@ public: bool success = thread_mgr->SendEvent(Object(), name, num_vals, val); if ( ! success ) - zeek::reporter->Error("SendEvent for event %s failed", name); + reporter->Error("SendEvent for event %s failed", name); return true; // We do not want to die if sendEvent fails because the event did not return. } @@ -157,35 +157,35 @@ bool ReporterMessage::Process() switch ( type ) { case INFO: - zeek::reporter->Info("%s: %s", Object()->Name(), msg); + reporter->Info("%s: %s", Object()->Name(), msg); break; case WARNING: - zeek::reporter->Warning("%s: %s", Object()->Name(), msg); + reporter->Warning("%s: %s", Object()->Name(), msg); break; case ERROR: - zeek::reporter->Error("%s: %s", Object()->Name(), msg); + reporter->Error("%s: %s", Object()->Name(), msg); break; case FATAL_ERROR: - zeek::reporter->FatalError("%s: %s", Object()->Name(), msg); + reporter->FatalError("%s: %s", Object()->Name(), msg); break; case FATAL_ERROR_WITH_CORE: - zeek::reporter->FatalErrorWithCore("%s: %s", Object()->Name(), msg); + reporter->FatalErrorWithCore("%s: %s", Object()->Name(), msg); break; case INTERNAL_WARNING: - zeek::reporter->InternalWarning("%s: %s", Object()->Name(), msg); + reporter->InternalWarning("%s: %s", Object()->Name(), msg); break; case INTERNAL_ERROR : - zeek::reporter->InternalError("%s: %s", Object()->Name(), msg); + reporter->InternalError("%s: %s", Object()->Name(), msg); break; default: - zeek::reporter->InternalError("unknown ReporterMessage type %d", type); + reporter->InternalError("unknown ReporterMessage type %d", type); } return true; @@ -209,8 +209,8 @@ MsgThread::MsgThread() : BasicThread(), queue_in(this, nullptr), queue_out(nullp failed = false; thread_mgr->AddMsgThread(this); - if ( ! zeek::iosource_mgr->RegisterFd(flare.FD(), this) ) - zeek::reporter->FatalError("Failed to register MsgThread fd with iosource_mgr"); + if ( ! iosource_mgr->RegisterFd(flare.FD(), this) ) + reporter->FatalError("Failed to register MsgThread fd with iosource_mgr"); SetClosed(false); } @@ -219,7 +219,7 @@ MsgThread::~MsgThread() { // Unregister this thread from the iosource manager so it doesn't wake // up the main poll anymore. - zeek::iosource_mgr->UnregisterFd(flare.FD(), this); + iosource_mgr->UnregisterFd(flare.FD(), this); } void MsgThread::OnSignalStop() @@ -229,7 +229,7 @@ void MsgThread::OnSignalStop() child_sent_finish = true; // Signal thread to terminate. - SendIn(new detail::FinishMessage(this, zeek::run_state::network_time), true); + SendIn(new detail::FinishMessage(this, run_state::network_time), true); } void MsgThread::OnWaitForStop() @@ -276,7 +276,7 @@ void MsgThread::OnWaitForStop() assert ( msg ); if ( ! msg->Process() ) - zeek::reporter->Error("%s failed during thread termination", msg->Name()); + reporter->Error("%s failed during thread termination", msg->Name()); delete msg; } @@ -303,7 +303,7 @@ void MsgThread::Heartbeat() if ( child_sent_finish ) return; - SendIn(new detail::HeartbeatMessage(this, zeek::run_state::network_time, zeek::util::current_time())); + SendIn(new detail::HeartbeatMessage(this, run_state::network_time, util::current_time())); } void MsgThread::Finished() @@ -351,7 +351,7 @@ void MsgThread::InternalError(const char* msg) #ifdef DEBUG -void MsgThread::Debug(zeek::DebugStream stream, const char* msg) +void MsgThread::Debug(DebugStream stream, const char* msg) { SendOut(new detail::DebugMessage(stream, this, msg)); } @@ -366,7 +366,7 @@ void MsgThread::SendIn(BasicInputMessage* msg, bool force) return; } - DBG_LOG(zeek::DBG_THREADING, "Sending '%s' to %s ...", msg->Name(), Name()); + DBG_LOG(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(zeek::DBG_THREADING, "Retrieved '%s' from %s", msg->Name(), Name()); + DBG_LOG(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(zeek::DBG_THREADING, s.c_str()); + Debug(DBG_THREADING, s.c_str()); #endif return msg; @@ -450,7 +450,7 @@ void MsgThread::Run() // anymore. if ( ! child_finished && ! Killed() ) { - OnFinish(zeek::run_state::network_time); + OnFinish(run_state::network_time); Finished(); } } @@ -476,7 +476,7 @@ void MsgThread::Process() if ( ! msg->Process() ) { - zeek::reporter->Error("%s failed, terminating thread", msg->Name()); + reporter->Error("%s failed, terminating thread", msg->Name()); SignalStop(); } diff --git a/src/threading/MsgThread.h b/src/threading/MsgThread.h index 0c1f7b706e..5c66429281 100644 --- a/src/threading/MsgThread.h +++ b/src/threading/MsgThread.h @@ -43,7 +43,7 @@ class KillMeMessage; * that happens, the thread stops accepting any new messages, finishes * processes all remaining ones still in the queue, and then exits. */ -class MsgThread : public BasicThread, public zeek::iosource::IOSource +class MsgThread : public BasicThread, public iosource::IOSource { public: /** @@ -88,7 +88,7 @@ public: * * @param vals the values to be given to the event */ - void SendEvent(const char* name, const int num_vals, threading::Value* *vals); + void SendEvent(const char* name, const int num_vals, Value* *vals); /** * Reports an informational message from the child thread. The main @@ -186,7 +186,7 @@ public: * * @param msg The message. It will be prefixed with the thread's name. */ - void Debug(zeek::DebugStream stream, const char* msg); + void Debug(DebugStream stream, const char* msg); #endif /** @@ -386,7 +386,7 @@ protected: * mainly for debugging purposes. */ explicit Message(const char* arg_name) - { name = zeek::util::copy_string(arg_name); } + { name = util::copy_string(arg_name); } private: const char* name; diff --git a/src/threading/Queue.h b/src/threading/Queue.h index e3db579557..0d44a9c62c 100644 --- a/src/threading/Queue.h +++ b/src/threading/Queue.h @@ -127,7 +127,7 @@ inline static std::unique_lock acquire_lock(std::mutex& m) } catch ( const std::system_error& e ) { - zeek::reporter->FatalErrorWithCore("cannot lock mutex: %s", e.what()); + reporter->FatalErrorWithCore("cannot lock mutex: %s", e.what()); // Never gets here. throw std::exception(); } @@ -218,7 +218,7 @@ inline std::vector> Queue::LocksForAllQueues() catch ( const std::system_error& e ) { - zeek::reporter->FatalErrorWithCore("cannot lock all mutexes: %s", e.what()); + reporter->FatalErrorWithCore("cannot lock all mutexes: %s", e.what()); // Never gets here. throw std::exception(); } diff --git a/src/threading/SerialTypes.cc b/src/threading/SerialTypes.cc index 5593bf4da2..a6f0f59345 100644 --- a/src/threading/SerialTypes.cc +++ b/src/threading/SerialTypes.cc @@ -16,7 +16,7 @@ namespace zeek::threading { -bool Field::Read(zeek::detail::SerializationFormat* fmt) +bool Field::Read(detail::SerializationFormat* fmt) { int t; int st; @@ -32,7 +32,7 @@ bool Field::Read(zeek::detail::SerializationFormat* fmt) if ( ! fmt->Read(&tmp_secondary_name, "secondary_name") ) return false; - secondary_name = zeek::util::copy_string(tmp_secondary_name.c_str()); + secondary_name = util::copy_string(tmp_secondary_name.c_str()); } else secondary_name = nullptr; @@ -45,15 +45,15 @@ bool Field::Read(zeek::detail::SerializationFormat* fmt) if ( ! success ) return false; - name = zeek::util::copy_string(tmp_name.c_str()); + name = util::copy_string(tmp_name.c_str()); - type = static_cast(t); - subtype = static_cast(st); + type = static_cast(t); + subtype = static_cast(st); return true; } -bool Field::Write(zeek::detail::SerializationFormat* fmt) const +bool Field::Write(detail::SerializationFormat* fmt) const { assert(name); @@ -79,15 +79,15 @@ std::string Field::TypeName() const // We do not support tables, if the internal Bro type is table it // always is a set. - if ( type == zeek::TYPE_TABLE ) + if ( type == TYPE_TABLE ) n = "set"; else - n = zeek::type_name(type); + n = type_name(type); - if ( (type == zeek::TYPE_TABLE) || (type == zeek::TYPE_VECTOR) ) + if ( (type == TYPE_TABLE) || (type == TYPE_VECTOR) ) { n += "["; - n += zeek::type_name(subtype); + n += type_name(subtype); n += "]"; } @@ -99,13 +99,13 @@ Value::~Value() if ( ! present ) return; - if ( type == zeek::TYPE_ENUM || type == zeek::TYPE_STRING || type == zeek::TYPE_FILE || type == zeek::TYPE_FUNC ) + if ( type == TYPE_ENUM || type == TYPE_STRING || type == TYPE_FILE || type == TYPE_FUNC ) delete [] val.string_val.data; - else if ( type == zeek::TYPE_PATTERN ) + else if ( type == TYPE_PATTERN ) delete [] val.pattern_text_val; - else if ( type == zeek::TYPE_TABLE ) + else if ( type == TYPE_TABLE ) { for ( bro_int_t i = 0; i < val.set_val.size; i++ ) delete val.set_val.vals[i]; @@ -113,7 +113,7 @@ Value::~Value() delete [] val.set_val.vals; } - else if ( type == zeek::TYPE_VECTOR ) + else if ( type == TYPE_VECTOR ) { for ( bro_int_t i = 0; i < val.vector_val.size; i++ ) delete val.vector_val.vals[i]; @@ -122,31 +122,31 @@ Value::~Value() } } -bool Value::IsCompatibleType(zeek::Type* t, bool atomic_only) +bool Value::IsCompatibleType(Type* t, bool atomic_only) { if ( ! t ) return false; switch ( t->Tag() ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: - case zeek::TYPE_COUNT: - case zeek::TYPE_PORT: - case zeek::TYPE_SUBNET: - case zeek::TYPE_ADDR: - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_FILE: - case zeek::TYPE_FUNC: + case TYPE_BOOL: + case TYPE_INT: + case TYPE_COUNT: + case TYPE_PORT: + case TYPE_SUBNET: + case TYPE_ADDR: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_FILE: + case TYPE_FUNC: return true; - case zeek::TYPE_RECORD: + case TYPE_RECORD: return ! atomic_only; - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( atomic_only ) return false; @@ -157,7 +157,7 @@ bool Value::IsCompatibleType(zeek::Type* t, bool atomic_only) return IsCompatibleType(t->AsSetType()->GetIndices()->GetPureType().get(), true); } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( atomic_only ) return false; @@ -172,28 +172,28 @@ bool Value::IsCompatibleType(zeek::Type* t, bool atomic_only) return false; } -bool Value::Read(zeek::detail::SerializationFormat* fmt) +bool Value::Read(detail::SerializationFormat* fmt) { int ty, sty; if ( ! (fmt->Read(&ty, "type") && fmt->Read(&sty, "subtype") && fmt->Read(&present, "present")) ) return false; - type = static_cast(ty); - subtype = static_cast(sty); + type = static_cast(ty); + subtype = static_cast(sty); if ( ! present ) return true; switch ( type ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_INT: return fmt->Read(&val.int_val, "int"); - case zeek::TYPE_COUNT: + case TYPE_COUNT: return fmt->Read(&val.uint_val, "uint"); - case zeek::TYPE_PORT: { + case TYPE_PORT: { int proto; if ( ! (fmt->Read(&val.port_val.port, "port") && fmt->Read(&proto, "proto") ) ) { return false; @@ -219,7 +219,7 @@ bool Value::Read(zeek::detail::SerializationFormat* fmt) return true; } - case zeek::TYPE_ADDR: + case TYPE_ADDR: { char family; @@ -241,7 +241,7 @@ bool Value::Read(zeek::detail::SerializationFormat* fmt) abort(); } - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { char length; char family; @@ -266,18 +266,18 @@ bool Value::Read(zeek::detail::SerializationFormat* fmt) abort(); } - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: return fmt->Read(&val.double_val, "double"); - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_FILE: - case zeek::TYPE_FUNC: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_FILE: + case TYPE_FUNC: return fmt->Read(&val.string_val.data, &val.string_val.length, "string"); - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( ! fmt->Read(&val.set_val.size, "set_size") ) return false; @@ -295,7 +295,7 @@ bool Value::Read(zeek::detail::SerializationFormat* fmt) return true; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( ! fmt->Read(&val.vector_val.size, "vector_size") ) return false; @@ -314,14 +314,14 @@ bool Value::Read(zeek::detail::SerializationFormat* fmt) } default: - zeek::reporter->InternalError("unsupported type %s in Value::Read", - zeek::type_name(type)); + reporter->InternalError("unsupported type %s in Value::Read", + type_name(type)); } return false; } -bool Value::Write(zeek::detail::SerializationFormat* fmt) const +bool Value::Write(detail::SerializationFormat* fmt) const { if ( ! (fmt->Write((int)type, "type") && fmt->Write((int)subtype, "subtype") && @@ -332,17 +332,17 @@ bool Value::Write(zeek::detail::SerializationFormat* fmt) const return true; switch ( type ) { - case zeek::TYPE_BOOL: - case zeek::TYPE_INT: + case TYPE_BOOL: + case TYPE_INT: return fmt->Write(val.int_val, "int"); - case zeek::TYPE_COUNT: + case TYPE_COUNT: return fmt->Write(val.uint_val, "uint"); - case zeek::TYPE_PORT: + case TYPE_PORT: return fmt->Write(val.port_val.port, "port") && fmt->Write(val.port_val.proto, "proto"); - case zeek::TYPE_ADDR: + case TYPE_ADDR: { switch ( val.addr_val.family ) { case IPv4: @@ -358,7 +358,7 @@ bool Value::Write(zeek::detail::SerializationFormat* fmt) const abort(); } - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { if ( ! fmt->Write((char)val.subnet_val.length, "subnet-length") ) return false; @@ -377,18 +377,18 @@ bool Value::Write(zeek::detail::SerializationFormat* fmt) const abort(); } - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: return fmt->Write(val.double_val, "double"); - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_FILE: - case zeek::TYPE_FUNC: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_FILE: + case TYPE_FUNC: return fmt->Write(val.string_val.data, val.string_val.length, "string"); - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( ! fmt->Write(val.set_val.size, "set_size") ) return false; @@ -402,7 +402,7 @@ bool Value::Write(zeek::detail::SerializationFormat* fmt) const return true; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( ! fmt->Write(val.vector_val.size, "vector_size") ) return false; @@ -417,8 +417,8 @@ bool Value::Write(zeek::detail::SerializationFormat* fmt) const } default: - zeek::reporter->InternalError("unsupported type %s in Value::Write", - zeek::type_name(type)); + reporter->InternalError("unsupported type %s in Value::Write", + type_name(type)); } // unreachable @@ -433,7 +433,7 @@ void Value::delete_value_ptr_array(Value** vals, int num_fields) delete [] vals; } -zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool& have_error) +Val* Value::ValueToVal(const std::string& source, const Value* val, bool& have_error) { if ( have_error ) return nullptr; @@ -442,107 +442,107 @@ zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool& return nullptr; // unset field switch ( val->type ) { - case zeek::TYPE_BOOL: - return zeek::val_mgr->Bool(val->val.int_val)->Ref(); + case TYPE_BOOL: + return val_mgr->Bool(val->val.int_val)->Ref(); - case zeek::TYPE_INT: - return zeek::val_mgr->Int(val->val.int_val).release(); + case TYPE_INT: + return val_mgr->Int(val->val.int_val).release(); - case zeek::TYPE_COUNT: - return zeek::val_mgr->Count(val->val.int_val).release(); + case TYPE_COUNT: + return val_mgr->Count(val->val.int_val).release(); - case zeek::TYPE_DOUBLE: - return new zeek::DoubleVal(val->val.double_val); + case TYPE_DOUBLE: + return new DoubleVal(val->val.double_val); - case zeek::TYPE_TIME: - return new zeek::TimeVal(val->val.double_val); + case TYPE_TIME: + return new TimeVal(val->val.double_val); - case zeek::TYPE_INTERVAL: - return new zeek::IntervalVal(val->val.double_val); + case TYPE_INTERVAL: + return new IntervalVal(val->val.double_val); - case zeek::TYPE_STRING: + case TYPE_STRING: { - auto* s = new zeek::String((const u_char*)val->val.string_val.data, val->val.string_val.length, true); - return new zeek::StringVal(s); + auto* s = new String((const u_char*)val->val.string_val.data, val->val.string_val.length, true); + return new StringVal(s); } - case zeek::TYPE_PORT: - return zeek::val_mgr->Port(val->val.port_val.port, val->val.port_val.proto)->Ref(); + case TYPE_PORT: + return val_mgr->Port(val->val.port_val.port, val->val.port_val.proto)->Ref(); - case zeek::TYPE_ADDR: + case TYPE_ADDR: { - zeek::IPAddr* addr = nullptr; + IPAddr* addr = nullptr; switch ( val->val.addr_val.family ) { case IPv4: - addr = new zeek::IPAddr(val->val.addr_val.in.in4); + addr = new IPAddr(val->val.addr_val.in.in4); break; case IPv6: - addr = new zeek::IPAddr(val->val.addr_val.in.in6); + addr = new IPAddr(val->val.addr_val.in.in6); break; default: assert(false); } - auto* addrval = new zeek::AddrVal(*addr); + auto* addrval = new AddrVal(*addr); delete addr; return addrval; } - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { - zeek::IPAddr* addr = nullptr; + IPAddr* addr = nullptr; switch ( val->val.subnet_val.prefix.family ) { case IPv4: - addr = new zeek::IPAddr(val->val.subnet_val.prefix.in.in4); + addr = new IPAddr(val->val.subnet_val.prefix.in.in4); break; case IPv6: - addr = new zeek::IPAddr(val->val.subnet_val.prefix.in.in6); + addr = new IPAddr(val->val.subnet_val.prefix.in.in6); break; default: assert(false); } - auto* subnetval = new zeek::SubNetVal(*addr, val->val.subnet_val.length); + auto* subnetval = new SubNetVal(*addr, val->val.subnet_val.length); delete addr; return subnetval; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { - auto* re = new zeek::RE_Matcher(val->val.pattern_text_val); + auto* re = new RE_Matcher(val->val.pattern_text_val); re->Compile(); - return new zeek::PatternVal(re); + return new PatternVal(re); } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { - zeek::TypeListPtr set_index; - if ( val->val.set_val.size == 0 && val->subtype == zeek::TYPE_VOID ) + TypeListPtr set_index; + if ( val->val.set_val.size == 0 && val->subtype == TYPE_VOID ) // don't know type - unspecified table. - set_index = zeek::make_intrusive(); + set_index = make_intrusive(); else { // all entries have to have the same type... - zeek::TypeTag stag = val->subtype; - if ( stag == zeek::TYPE_VOID ) + TypeTag stag = val->subtype; + if ( stag == TYPE_VOID ) stag = val->val.set_val.vals[0]->type; - zeek::TypePtr index_type; + TypePtr index_type; - if ( stag == zeek::TYPE_ENUM ) + if ( stag == TYPE_ENUM ) { // Enums are not a base-type, so need to look it up. const auto& sv = val->val.set_val.vals[0]->val.string_val; std::string enum_name(sv.data, sv.length); - const auto& enum_id = zeek::detail::global_scope()->Find(enum_name); + const auto& enum_id = detail::global_scope()->Find(enum_name); if ( ! enum_id ) { - zeek::reporter->Warning("Value '%s' of source '%s' is not a valid enum.", + reporter->Warning("Value '%s' of source '%s' is not a valid enum.", enum_name.data(), source.c_str()); have_error = true; @@ -552,73 +552,73 @@ zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool& index_type = enum_id->GetType(); } else - index_type = zeek::base_type(stag); + index_type = base_type(stag); - set_index = zeek::make_intrusive(index_type); + set_index = make_intrusive(index_type); set_index->Append(std::move(index_type)); } - auto s = zeek::make_intrusive(std::move(set_index), nullptr); - auto* t = new zeek::TableVal(std::move(s)); + auto s = make_intrusive(std::move(set_index), nullptr); + auto* t = new TableVal(std::move(s)); for ( int j = 0; j < val->val.set_val.size; j++ ) { - zeek::Val* assignval = ValueToVal(source, val->val.set_val.vals[j], have_error); - t->Assign({zeek::AdoptRef{}, assignval}, nullptr); + Val* assignval = ValueToVal(source, val->val.set_val.vals[j], have_error); + t->Assign({AdoptRef{}, assignval}, nullptr); } return t; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { - zeek::TypePtr type; + TypePtr type; - if ( val->val.vector_val.size == 0 && val->subtype == zeek::TYPE_VOID ) + if ( val->val.vector_val.size == 0 && val->subtype == TYPE_VOID ) // don't know type - unspecified table. - type = zeek::base_type(zeek::TYPE_ANY); + type = base_type(TYPE_ANY); else { // all entries have to have the same type... - if ( val->subtype == zeek::TYPE_VOID ) - type = zeek::base_type(val->val.vector_val.vals[0]->type); + if ( val->subtype == TYPE_VOID ) + type = base_type(val->val.vector_val.vals[0]->type); else - type = zeek::base_type(val->subtype); + type = base_type(val->subtype); } - auto vt = zeek::make_intrusive(std::move(type)); - auto v = zeek::make_intrusive(std::move(vt)); + auto vt = make_intrusive(std::move(type)); + auto v = make_intrusive(std::move(vt)); for ( int j = 0; j < val->val.vector_val.size; j++ ) { auto el = ValueToVal(source, val->val.vector_val.vals[j], have_error); - v->Assign(j, {zeek::AdoptRef{}, el}); + v->Assign(j, {AdoptRef{}, el}); } return v.release(); } - case zeek::TYPE_ENUM: { + case TYPE_ENUM: { // Convert to string first to not have to deal with missing // \0's... std::string enum_string(val->val.string_val.data, val->val.string_val.length); // let's try looking it up by global ID. - const auto& id = zeek::detail::lookup_ID(enum_string.c_str(), zeek::detail::GLOBAL_MODULE_NAME); + const auto& id = detail::lookup_ID(enum_string.c_str(), detail::GLOBAL_MODULE_NAME); if ( ! id || ! id->IsEnumConst() ) { - zeek::reporter->Warning("Value '%s' for source '%s' is not a valid enum.", + reporter->Warning("Value '%s' for source '%s' is not a valid enum.", enum_string.c_str(), source.c_str()); have_error = true; return nullptr; } - zeek::EnumType* t = id->GetType()->AsEnumType(); + EnumType* t = id->GetType()->AsEnumType(); int intval = t->Lookup(id->ModuleName(), id->Name()); if ( intval < 0 ) { - zeek::reporter->Warning("Enum value '%s' for source '%s' not found.", + reporter->Warning("Enum value '%s' for source '%s' not found.", enum_string.c_str(), source.c_str()); have_error = true; @@ -630,7 +630,7 @@ zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool& } default: - zeek::reporter->InternalError("Unsupported type in SerialTypes::ValueToVal from source %s", source.c_str()); + reporter->InternalError("Unsupported type in SerialTypes::ValueToVal from source %s", source.c_str()); } assert(false); diff --git a/src/threading/SerialTypes.h b/src/threading/SerialTypes.h index 2a869c6126..92095341ab 100644 --- a/src/threading/SerialTypes.h +++ b/src/threading/SerialTypes.h @@ -21,24 +21,24 @@ struct Field { //! Needed by input framework. Port fields have two names (one for the //! port, one for the type), and this specifies the secondary name. const char* secondary_name; - zeek::TypeTag type; //! Type of the field. - zeek::TypeTag subtype; //! Inner type for sets and vectors. + TypeTag type; //! Type of the field. + TypeTag subtype; //! Inner type for sets and vectors. bool optional; //! True if field is optional. /** * Constructor. */ - Field(const char* name, const char* secondary_name, zeek::TypeTag type, zeek::TypeTag subtype, bool optional) - : name(name ? zeek::util::copy_string(name) : nullptr), - secondary_name(secondary_name ? zeek::util::copy_string(secondary_name) : nullptr), + Field(const char* name, const char* secondary_name, TypeTag type, TypeTag subtype, bool optional) + : name(name ? util::copy_string(name) : nullptr), + secondary_name(secondary_name ? util::copy_string(secondary_name) : nullptr), type(type), subtype(subtype), optional(optional) { } /** * Copy constructor. */ Field(const Field& other) - : name(other.name ? zeek::util::copy_string(other.name) : nullptr), - secondary_name(other.secondary_name ? zeek::util::copy_string(other.secondary_name) : nullptr), + : name(other.name ? util::copy_string(other.name) : nullptr), + secondary_name(other.secondary_name ? util::copy_string(other.secondary_name) : nullptr), type(other.type), subtype(other.subtype), optional(other.optional) { } ~Field() @@ -85,8 +85,8 @@ private: * those Vals supported). */ struct Value { - zeek::TypeTag type; //! The type of the value. - zeek::TypeTag subtype; //! Inner type for sets and vectors. + TypeTag type; //! The type of the value. + TypeTag subtype; //! Inner type for sets and vectors. bool present; //! False for optional record fields that are not set. struct set_t { bro_int_t size; Value** vals; }; @@ -141,8 +141,8 @@ struct Value { * arg_present: False if the value represents an optional record field * that is not set. */ - Value(zeek::TypeTag arg_type = zeek::TYPE_ERROR, bool arg_present = true) - : type(arg_type), subtype(zeek::TYPE_VOID), present(arg_present) + Value(TypeTag arg_type = TYPE_ERROR, bool arg_present = true) + : type(arg_type), subtype(TYPE_VOID), present(arg_present) {} /** @@ -155,7 +155,7 @@ struct Value { * arg_present: False if the value represents an optional record field * that is not set. */ - Value(zeek::TypeTag arg_type, zeek::TypeTag arg_subtype, bool arg_present = true) + Value(TypeTag arg_type, TypeTag arg_subtype, bool arg_present = true) : type(arg_type), subtype(arg_subtype), present(arg_present) {} @@ -187,7 +187,7 @@ struct Value { * Returns true if the type can be represented by a Value. If * `atomic_only` is true, will not permit composite types. This * method is thread-safe. */ - static bool IsCompatibleType(zeek::Type* t, bool atomic_only=false); + static bool IsCompatibleType(Type* t, bool atomic_only=false); /** * Convenience function to delete an array of value pointers. @@ -207,7 +207,7 @@ struct Value { * immediately aborts. * @return Val representation of the threading::Value. nullptr on error. */ - static zeek::Val* ValueToVal(const std::string& source, const threading::Value* val, bool& have_error); + static Val* ValueToVal(const std::string& source, const threading::Value* val, bool& have_error); private: friend class IPAddr; diff --git a/src/threading/formatters/Ascii.cc b/src/threading/formatters/Ascii.cc index 113ddf7fa7..aaf648c96a 100644 --- a/src/threading/formatters/Ascii.cc +++ b/src/threading/formatters/Ascii.cc @@ -16,13 +16,13 @@ namespace zeek::threading::formatter { // If the value we'd write out would match exactly the a reserved string, we // escape the first character so that the output won't be ambigious. If this // function returns true, it has added an escaped version of data to desc. -static inline bool escapeReservedContent(zeek::ODesc* desc, const string& reserved, const char* data, int size) +static inline bool escapeReservedContent(ODesc* desc, const string& reserved, const char* data, int size) { if ( size != (int)reserved.size() || memcmp(data, reserved.data(), size) != 0 ) return false; char hex[4] = {'\\', 'x', '0', '0'}; - zeek::util::bytetohex(*data, hex + 2); + util::bytetohex(*data, hex + 2); desc->AddRaw(hex, 4); desc->AddN(data + 1, size - 1); return true; @@ -48,7 +48,7 @@ Ascii::SeparatorInfo::SeparatorInfo(const string& arg_separator, empty_field = arg_empty_field; } -Ascii::Ascii(zeek::threading::MsgThread* t, const SeparatorInfo& info) : zeek::threading::Formatter(t) +Ascii::Ascii(MsgThread* t, const SeparatorInfo& info) : Formatter(t) { separators = info; } @@ -57,8 +57,8 @@ Ascii::~Ascii() { } -bool Ascii::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields, - zeek::threading::Value** vals) const +bool Ascii::Describe(ODesc* desc, int num_fields, const Field* const * fields, + Value** vals) const { for ( int i = 0; i < num_fields; i++ ) { @@ -72,7 +72,7 @@ bool Ascii::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::F return true; } -bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const string& name) const +bool Ascii::Describe(ODesc* desc, Value* val, const string& name) const { if ( ! val->present ) { @@ -82,49 +82,49 @@ bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const strin switch ( val->type ) { - case zeek::TYPE_BOOL: + case TYPE_BOOL: desc->Add(val->val.int_val ? "T" : "F"); break; - case zeek::TYPE_INT: + case TYPE_INT: desc->Add(val->val.int_val); break; - case zeek::TYPE_COUNT: + case TYPE_COUNT: desc->Add(val->val.uint_val); break; - case zeek::TYPE_PORT: + case TYPE_PORT: desc->Add(val->val.port_val.port); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: desc->Add(Render(val->val.subnet_val)); break; - case zeek::TYPE_ADDR: + case TYPE_ADDR: desc->Add(Render(val->val.addr_val)); break; - case zeek::TYPE_DOUBLE: + case TYPE_DOUBLE: // Rendering via Add() truncates trailing 0s after the // decimal point. The difference with TIME/INTERVAL is mainly // to keep the log format consistent. desc->Add(val->val.double_val, true); break; - case zeek::TYPE_INTERVAL: - case zeek::TYPE_TIME: + case TYPE_INTERVAL: + case TYPE_TIME: // Rendering via Render() keeps trailing 0s after the decimal // point. The difference with DOUBLE is mainly to keep the // log format consistent. desc->Add(Render(val->val.double_val)); break; - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_FILE: - case zeek::TYPE_FUNC: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_FILE: + case TYPE_FUNC: { int size = val->val.string_val.length; const char* data = val->val.string_val.data; @@ -145,7 +145,7 @@ bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const strin break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { if ( ! val->val.set_val.size ) { @@ -172,7 +172,7 @@ bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const strin break; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { if ( ! val->val.vector_val.size ) { @@ -208,30 +208,30 @@ bool Ascii::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const strin } -zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, zeek::TypeTag type, zeek::TypeTag subtype) const +Value* Ascii::ParseValue(const string& s, const string& name, TypeTag type, TypeTag subtype) const { if ( ! separators.unset_field.empty() && s.compare(separators.unset_field) == 0 ) // field is not set... - return new zeek::threading::Value(type, false); + return new Value(type, false); - zeek::threading::Value* val = new zeek::threading::Value(type, subtype, true); + Value* val = new Value(type, subtype, true); const char* start = s.c_str(); char* end = nullptr; errno = 0; size_t pos; switch ( type ) { - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: + case TYPE_ENUM: + case TYPE_STRING: { - string unescaped = zeek::util::get_unescaped_string(s); + string unescaped = util::get_unescaped_string(s); val->val.string_val.length = unescaped.size(); - val->val.string_val.data = zeek::util::copy_string(unescaped.c_str()); + val->val.string_val.data = util::copy_string(unescaped.c_str()); break; } - case zeek::TYPE_BOOL: + case TYPE_BOOL: { - auto stripped = zeek::util::strstrip(s); + auto stripped = util::strstrip(s); if ( stripped == "T" || stripped == "1" ) val->val.int_val = 1; else if ( stripped == "F" || stripped == "0" ) @@ -245,42 +245,42 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z break; } - case zeek::TYPE_INT: + case TYPE_INT: val->val.int_val = strtoll(start, &end, 10); if ( CheckNumberError(start, end) ) goto parse_error; break; - case zeek::TYPE_DOUBLE: - case zeek::TYPE_TIME: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_TIME: + case TYPE_INTERVAL: val->val.double_val = strtod(start, &end); if ( CheckNumberError(start, end) ) goto parse_error; break; - case zeek::TYPE_COUNT: + case TYPE_COUNT: val->val.uint_val = strtoull(start, &end, 10); if ( CheckNumberError(start, end) ) goto parse_error; break; - case zeek::TYPE_PORT: + case TYPE_PORT: { - auto stripped = zeek::util::strstrip(s); + auto stripped = util::strstrip(s); val->val.port_val.proto = TRANSPORT_UNKNOWN; pos = stripped.find('/'); string numberpart; if ( pos != std::string::npos && stripped.length() > pos + 1 ) { auto proto = stripped.substr(pos+1); - if ( zeek::util::strtolower(proto) == "tcp" ) + if ( util::strtolower(proto) == "tcp" ) val->val.port_val.proto = TRANSPORT_TCP; - else if ( zeek::util::strtolower(proto) == "udp" ) + else if ( util::strtolower(proto) == "udp" ) val->val.port_val.proto = TRANSPORT_UDP; - else if ( zeek::util::strtolower(proto) == "icmp" ) + else if ( util::strtolower(proto) == "icmp" ) val->val.port_val.proto = TRANSPORT_ICMP; - else if ( zeek::util::strtolower(proto) == "unknown" ) + else if ( util::strtolower(proto) == "unknown" ) val->val.port_val.proto = TRANSPORT_UNKNOWN; else GetThread()->Warning(GetThread()->Fmt("Port '%s' contained unknown protocol '%s'", s.c_str(), proto.c_str())); @@ -297,9 +297,9 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z } break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: { - string unescaped = zeek::util::strstrip(zeek::util::get_unescaped_string(s)); + string unescaped = util::strstrip(util::get_unescaped_string(s)); size_t pos = unescaped.find('/'); if ( pos == unescaped.npos ) { @@ -320,16 +320,16 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z break; } - case zeek::TYPE_ADDR: + case TYPE_ADDR: { - string unescaped = zeek::util::strstrip(zeek::util::get_unescaped_string(s)); + string unescaped = util::strstrip(util::get_unescaped_string(s)); val->val.addr_val = ParseAddr(unescaped); break; } - case zeek::TYPE_PATTERN: + case TYPE_PATTERN: { - string candidate = zeek::util::get_unescaped_string(s); + string candidate = util::get_unescaped_string(s); // A string is a candidate pattern iff it begins and ends with // a '/'. Rather or not the rest of the string is legal will // be determined later when it is given to the RE engine. @@ -341,7 +341,7 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z // Remove the '/'s candidate.erase(0, 1); candidate.erase(candidate.size() - 1); - val->val.pattern_text_val = zeek::util::copy_string(candidate.c_str()); + val->val.pattern_text_val = util::copy_string(candidate.c_str()); break; } } @@ -350,8 +350,8 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z goto parse_error; } - case zeek::TYPE_TABLE: - case zeek::TYPE_VECTOR: + case TYPE_TABLE: + case TYPE_VECTOR: // First - common initialization // Then - initialization for table. // Then - initialization for vector. @@ -374,15 +374,15 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z if ( separators.empty_field.empty() && s.empty() ) length = 0; - zeek::threading::Value** lvals = new zeek::threading::Value* [length]; + Value** lvals = new Value* [length]; - if ( type == zeek::TYPE_TABLE ) + if ( type == TYPE_TABLE ) { val->val.set_val.vals = lvals; val->val.set_val.size = length; } - else if ( type == zeek::TYPE_VECTOR ) + else if ( type == TYPE_VECTOR ) { val->val.vector_val.vals = lvals; val->val.vector_val.size = length; @@ -410,7 +410,7 @@ zeek::threading::Value* Ascii::ParseValue(const string& s, const string& name, z break; } - zeek::threading::Value* newval = ParseValue(element, name, subtype); + Value* newval = ParseValue(element, name, subtype); if ( newval == nullptr ) { GetThread()->Warning("Error while reading set or vector"); @@ -475,7 +475,7 @@ parse_error: bool Ascii::CheckNumberError(const char* start, const char* end) const { - zeek::threading::MsgThread* thread = GetThread(); + MsgThread* thread = GetThread(); if ( end == start && *end != '\0' ) { thread->Warning(thread->Fmt("String '%s' contained no parseable number", start)); diff --git a/src/threading/formatters/Ascii.h b/src/threading/formatters/Ascii.h index f8b0607a0c..79eacc947b 100644 --- a/src/threading/formatters/Ascii.h +++ b/src/threading/formatters/Ascii.h @@ -6,7 +6,7 @@ namespace zeek::threading::formatter { -class Ascii final : public zeek::threading::Formatter { +class Ascii final : public Formatter { public: /** * A struct to pass the necessary configuration values to the @@ -44,14 +44,14 @@ public: * @param info SeparatorInfo structure defining the necessary * separators. */ - Ascii(zeek::threading::MsgThread* t, const SeparatorInfo& info); + Ascii(MsgThread* t, const SeparatorInfo& info); virtual ~Ascii(); - virtual bool Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name = "") const; - virtual bool Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields, - zeek::threading::Value** vals) const; - virtual zeek::threading::Value* ParseValue(const std::string& s, const std::string& name, - zeek::TypeTag type, zeek::TypeTag subtype = zeek::TYPE_ERROR) const; + virtual bool Describe(ODesc* desc, Value* val, const std::string& name = "") const; + virtual bool Describe(ODesc* desc, int num_fields, const Field* const * fields, + Value** vals) const; + virtual Value* ParseValue(const std::string& s, const std::string& name, + TypeTag type, TypeTag subtype = TYPE_ERROR) const; private: bool CheckNumberError(const char* start, const char* end) const; diff --git a/src/threading/formatters/JSON.cc b/src/threading/formatters/JSON.cc index eb41ca1e55..959b285fab 100644 --- a/src/threading/formatters/JSON.cc +++ b/src/threading/formatters/JSON.cc @@ -26,7 +26,7 @@ bool JSON::NullDoubleWriter::Double(double d) return rapidjson::Writer::Double(d); } -JSON::JSON(zeek::threading::MsgThread* t, TimeFormat tf) : zeek::threading::Formatter(t), surrounding_braces(true) +JSON::JSON(MsgThread* t, TimeFormat tf) : Formatter(t), surrounding_braces(true) { timestamps = tf; } @@ -35,8 +35,8 @@ JSON::~JSON() { } -bool JSON::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields, - zeek::threading::Value** vals) const +bool JSON::Describe(ODesc* desc, int num_fields, const Field* const * fields, + Value** vals) const { rapidjson::StringBuffer buffer; NullDoubleWriter writer(buffer); @@ -55,7 +55,7 @@ bool JSON::Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Fi return true; } -bool JSON::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name) const +bool JSON::Describe(ODesc* desc, Value* val, const std::string& name) const { if ( desc->IsBinary() ) { @@ -78,14 +78,14 @@ bool JSON::Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::s return true; } -zeek::threading::Value* JSON::ParseValue(const std::string& s, const std::string& name, - zeek::TypeTag type, zeek::TypeTag subtype) const +Value* JSON::ParseValue(const std::string& s, const std::string& name, + TypeTag type, TypeTag subtype) const { GetThread()->Error("JSON formatter does not support parsing yet."); return nullptr; } -void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, const std::string& name) const +void JSON::BuildJSON(NullDoubleWriter& writer, Value* val, const std::string& name) const { if ( ! val->present ) { @@ -98,36 +98,36 @@ void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, cons switch ( val->type ) { - case zeek::TYPE_BOOL: + case TYPE_BOOL: writer.Bool(val->val.int_val != 0); break; - case zeek::TYPE_INT: + case TYPE_INT: writer.Int64(val->val.int_val); break; - case zeek::TYPE_COUNT: + case TYPE_COUNT: writer.Uint64(val->val.uint_val); break; - case zeek::TYPE_PORT: + case TYPE_PORT: writer.Uint64(val->val.port_val.port); break; - case zeek::TYPE_SUBNET: + case TYPE_SUBNET: writer.String(Formatter::Render(val->val.subnet_val)); break; - case zeek::TYPE_ADDR: + case TYPE_ADDR: writer.String(Formatter::Render(val->val.addr_val)); break; - case zeek::TYPE_DOUBLE: - case zeek::TYPE_INTERVAL: + case TYPE_DOUBLE: + case TYPE_INTERVAL: writer.Double(val->val.double_val); break; - case zeek::TYPE_TIME: + case TYPE_TIME: { if ( timestamps == TS_ISO8601 ) { @@ -169,17 +169,17 @@ void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, cons break; } - case zeek::TYPE_ENUM: - case zeek::TYPE_STRING: - case zeek::TYPE_FILE: - case zeek::TYPE_FUNC: + case TYPE_ENUM: + case TYPE_STRING: + case TYPE_FILE: + case TYPE_FUNC: { - writer.String(zeek::util::json_escape_utf8( + writer.String(util::json_escape_utf8( std::string(val->val.string_val.data, val->val.string_val.length))); break; } - case zeek::TYPE_TABLE: + case TYPE_TABLE: { writer.StartArray(); @@ -190,7 +190,7 @@ void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, cons break; } - case zeek::TYPE_VECTOR: + case TYPE_VECTOR: { writer.StartArray(); @@ -202,7 +202,7 @@ void JSON::BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, cons } default: - zeek::reporter->Warning("Unhandled type in JSON::BuildJSON"); + reporter->Warning("Unhandled type in JSON::BuildJSON"); break; } } diff --git a/src/threading/formatters/JSON.h b/src/threading/formatters/JSON.h index 70fac3089e..3eb7e1a002 100644 --- a/src/threading/formatters/JSON.h +++ b/src/threading/formatters/JSON.h @@ -14,7 +14,7 @@ namespace zeek::threading::formatter { * A thread-safe class for converting values into a JSON representation * and vice versa. */ -class JSON : public zeek::threading::Formatter { +class JSON : public Formatter { public: enum TimeFormat { TS_EPOCH, // Doubles that represents seconds from the UNIX epoch. @@ -22,14 +22,14 @@ public: TS_MILLIS // Milliseconds from the UNIX epoch. Some consumers need this (e.g., elasticsearch). }; - JSON(zeek::threading::MsgThread* t, TimeFormat tf); + JSON(MsgThread* t, TimeFormat tf); ~JSON() override; - bool Describe(zeek::ODesc* desc, zeek::threading::Value* val, const std::string& name = "") const override; - bool Describe(zeek::ODesc* desc, int num_fields, const zeek::threading::Field* const * fields, - zeek::threading::Value** vals) const override; - zeek::threading::Value* ParseValue(const std::string& s, const std::string& name, zeek::TypeTag type, - zeek::TypeTag subtype = zeek::TYPE_ERROR) const override; + bool Describe(ODesc* desc, Value* val, const std::string& name = "") const override; + bool Describe(ODesc* desc, int num_fields, const Field* const * fields, + Value** vals) const override; + Value* ParseValue(const std::string& s, const std::string& name, TypeTag type, + TypeTag subtype = TYPE_ERROR) const override; class NullDoubleWriter : public rapidjson::Writer { public: @@ -38,7 +38,7 @@ public: }; private: - void BuildJSON(NullDoubleWriter& writer, zeek::threading::Value* val, const std::string& name = "") const; + void BuildJSON(NullDoubleWriter& writer, Value* val, const std::string& name = "") const; TimeFormat timestamps; bool surrounding_braces; diff --git a/src/util.cc b/src/util.cc index 36f3d19139..5d4189a0b7 100644 --- a/src/util.cc +++ b/src/util.cc @@ -218,7 +218,7 @@ int expand_escape(const char*& s) if ( result < 0 ) { - zeek::reporter->Error("bad octal escape: %s", start); + reporter->Error("bad octal escape: %s", start); return 0; } @@ -253,7 +253,7 @@ int expand_escape(const char*& s) if ( result < 0 ) { - zeek::reporter->Error("bad hexadecimal escape: %s", start); + reporter->Error("bad hexadecimal escape: %s", start); return 0; } @@ -282,7 +282,7 @@ const char* fmt_access_time(double t) if ( ! localtime_r(&time, &ts) ) { - zeek::reporter->InternalError("unable to get time"); + reporter->InternalError("unable to get time"); } strftime(buf, sizeof(buf), "%d/%m-%H:%M", &ts); @@ -327,22 +327,22 @@ bool ensure_dir(const char *dirname) { // Show the original failure reason for mkdir() since nothing's there // or we can't even tell what is now. - zeek::reporter->Warning("can't create directory %s: %s", - dirname, strerror(mkdir_errno)); + reporter->Warning("can't create directory %s: %s", + dirname, strerror(mkdir_errno)); return false; } if ( S_ISDIR(st.st_mode) ) return true; - zeek::reporter->Warning("%s exists but is not a directory", dirname); + reporter->Warning("%s exists but is not a directory", dirname); return false; } void hmac_md5(size_t size, const unsigned char* bytes, unsigned char digest[16]) { if ( ! zeek::detail::KeyedHash::seeds_initialized ) - zeek::reporter->InternalError("HMAC-MD5 invoked before the HMAC key is set"); + reporter->InternalError("HMAC-MD5 invoked before the HMAC key is set"); zeek::detail::internal_md5(bytes, size, digest); @@ -359,8 +359,8 @@ static bool read_random_seeds(const char* read_file, uint32_t* seed, if ( ! (f = fopen(read_file, "r")) ) { - zeek::reporter->Warning("Could not open seed file '%s': %s", - read_file, strerror(errno)); + reporter->Warning("Could not open seed file '%s': %s", + read_file, strerror(errno)); return false; } @@ -395,8 +395,8 @@ static bool write_random_seeds(const char* write_file, uint32_t seed, if ( ! (f = fopen(write_file, "w+")) ) { - zeek::reporter->Warning("Could not create seed file '%s': %s", - write_file, strerror(errno)); + reporter->Warning("Could not create seed file '%s': %s", + write_file, strerror(errno)); return false; } @@ -441,8 +441,8 @@ void init_random_seed(const char* read_file, const char* write_file, if ( read_file ) { if ( ! read_random_seeds(read_file, &seed, buf) ) - zeek::reporter->FatalError("Could not load seeds from file '%s'.\n", - read_file); + reporter->FatalError("Could not load seeds from file '%s'.\n", + read_file); else seeds_done = true; } @@ -487,8 +487,8 @@ void init_random_seed(const char* read_file, const char* write_file, #endif if ( pos < zeek::detail::KeyedHash::SEED_INIT_SIZE ) - zeek::reporter->FatalError("Could not read enough random data. Wanted %d, got %zu", - zeek::detail::KeyedHash::SEED_INIT_SIZE, pos); + reporter->FatalError("Could not read enough random data. Wanted %d, got %zu", + zeek::detail::KeyedHash::SEED_INIT_SIZE, pos); if ( ! seed ) { @@ -514,8 +514,8 @@ void init_random_seed(const char* read_file, const char* write_file, zeek::detail::KeyedHash::InitializeSeeds(buf); if ( write_file && ! write_random_seeds(write_file, seed, buf) ) - zeek::reporter->Error("Could not write seeds to file '%s'.\n", - write_file); + reporter->Error("Could not write seeds to file '%s'.\n", + write_file); } unsigned int initial_seed() @@ -587,7 +587,7 @@ void warn_if_legacy_script(std::string_view filename) if ( ends_with(filename, ".bro") ) { std::string x(filename); - zeek::reporter->Warning("Loading script '%s' with legacy extension, support for '.bro' will be removed in Zeek v4.1", x.c_str()); + reporter->Warning("Loading script '%s' with legacy extension, support for '.bro' will be removed in Zeek v4.1", x.c_str()); } } @@ -639,8 +639,8 @@ FILE* open_package(string& path, const string& mode) path.append(script_extensions[0]); string package_loader = "__load__" + script_extensions[0]; - zeek::reporter->Error("Failed to open package '%s': missing '%s' file", - arg_path.c_str(), package_loader.c_str()); + reporter->Error("Failed to open package '%s': missing '%s' file", + arg_path.c_str(), package_loader.c_str()); return nullptr; } @@ -655,8 +655,8 @@ void SafePathOp::CheckValid(const char* op_result, const char* path, else { if ( error_aborts ) - zeek::reporter->InternalError("Path operation failed on %s: %s", - path ? path : "", strerror(errno)); + reporter->InternalError("Path operation failed on %s: %s", + path ? path : "", strerror(errno)); else error = true; } @@ -843,7 +843,7 @@ std::string get_exe_path(const std::string& invocation) return find_file(invocation, path); } -FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info) +FILE* rotate_file(const char* name, RecordVal* rotate_info) { // Build file names. const int buflen = strlen(name) + 128; @@ -854,7 +854,7 @@ FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info) auto tmpname = tmpname_buf.get(); snprintf(newname, buflen, "%s.%d.%.06f.tmp", - name, getpid(), zeek::run_state::network_time); + name, getpid(), run_state::network_time); newname[buflen-1] = '\0'; strcpy(tmpname, newname); strcat(tmpname, ".tmp"); @@ -863,7 +863,7 @@ FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info) FILE* newf = fopen(tmpname, "w"); if ( ! newf ) { - zeek::reporter->Error("rotate_file: can't open %s: %s", tmpname, strerror(errno)); + reporter->Error("rotate_file: can't open %s: %s", tmpname, strerror(errno)); return nullptr; } @@ -872,7 +872,7 @@ FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info) struct stat dummy; if ( link(name, newname) < 0 || stat(newname, &dummy) < 0 ) { - zeek::reporter->Error("rotate_file: can't move %s to %s: %s", name, newname, strerror(errno)); + reporter->Error("rotate_file: can't move %s to %s: %s", name, newname, strerror(errno)); fclose(newf); unlink(newname); unlink(tmpname); @@ -882,17 +882,17 @@ FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info) // Close current file, and move the tmp to its place. if ( unlink(name) < 0 || link(tmpname, name) < 0 || unlink(tmpname) < 0 ) { - zeek::reporter->Error("rotate_file: can't move %s to %s: %s", tmpname, name, strerror(errno)); + reporter->Error("rotate_file: can't move %s to %s: %s", tmpname, name, strerror(errno)); exit(1); // hard to fix, but shouldn't happen anyway... } // Init rotate_info. if ( rotate_info ) { - rotate_info->Assign(0, name); - rotate_info->Assign(1, newname); - rotate_info->Assign(2, zeek::run_state::network_time); - rotate_info->Assign(3, zeek::run_state::network_time); + rotate_info->Assign(0, name); + rotate_info->Assign(1, newname); + rotate_info->Assign(2, run_state::network_time); + rotate_info->Assign(3, run_state::network_time); } return newf; @@ -912,7 +912,7 @@ double parse_rotate_base_time(const char* rotate_base_time) { struct tm t; if ( ! strptime(rotate_base_time, "%H:%M", &t) ) - zeek::reporter->Error("calc_next_rotate(): can't parse rotation base time"); + reporter->Error("calc_next_rotate(): can't parse rotation base time"); else base = t.tm_min * 60 + t.tm_hour * 60 * 60; } @@ -924,7 +924,7 @@ double calc_next_rotate(double current, double interval, double base) { if ( ! interval ) { - zeek::reporter->Error("calc_next_rotate(): interval is zero, falling back to 24hrs"); + reporter->Error("calc_next_rotate(): interval is zero, falling back to 24hrs"); interval = 86400; } @@ -934,7 +934,7 @@ double calc_next_rotate(double current, double interval, double base) struct tm t; if ( ! localtime_r(&teatime, &t) ) { - zeek::reporter->Error("calc_next_rotate(): failure processing current time (%.6f)", current); + reporter->Error("calc_next_rotate(): failure processing current time (%.6f)", current); // fall back to the method used if no base time is given base = -1; @@ -957,7 +957,7 @@ double calc_next_rotate(double current, double interval, double base) void terminate_processing() { - if ( ! zeek::run_state::terminating ) + if ( ! run_state::terminating ) raise(SIGTERM); } @@ -978,9 +978,9 @@ void set_processing_status(const char* status, const char* reason) { char buf[256]; zeek_strerror_r(errno, buf, sizeof(buf)); - if ( zeek::reporter ) - zeek::reporter->Error("Failed to open process status file '%s': %s", - proc_status_file, buf); + if ( reporter ) + reporter->Error("Failed to open process status file '%s': %s", + proc_status_file, buf); else fprintf(stderr, "Failed to open process status file '%s': %s\n", proc_status_file, buf); @@ -1079,14 +1079,14 @@ TEST_CASE("util get_escaped_string") { SUBCASE("returned ODesc") { - zeek::ODesc* d = get_escaped_string(nullptr, "a bcd\n", 6, false); + ODesc* d = get_escaped_string(nullptr, "a bcd\n", 6, false); CHECK(strcmp(d->Description(), "a\\x20bcd\\x0a") == 0); delete d; } SUBCASE("provided ODesc") { - zeek::ODesc d2; + ODesc d2; get_escaped_string(&d2, "ab\\e", 4, true); CHECK(strcmp(d2.Description(), "\\x61\\x62\\\\\\x65") == 0); } @@ -1113,11 +1113,11 @@ TEST_CASE("util get_escaped_string") * ASCII. * @return A ODesc object containing a list of escaped hex values of the form * \x##, which may be newly allocated if \a d was a null pointer. */ -zeek::ODesc* get_escaped_string(zeek::ODesc* d, const char* str, size_t len, - bool escape_all) +ODesc* get_escaped_string(ODesc* d, const char* str, size_t len, + bool escape_all) { if ( ! d ) - d = new zeek::ODesc(); + d = new ODesc(); for ( size_t i = 0; i < len; ++i ) { @@ -1144,7 +1144,7 @@ zeek::ODesc* get_escaped_string(zeek::ODesc* d, const char* str, size_t len, std::string get_escaped_string(const char* str, size_t len, bool escape_all) { - zeek::ODesc d; + ODesc d; return get_escaped_string(&d, str, len, escape_all)->Description(); } @@ -1308,7 +1308,7 @@ unsigned char encode_hex(int h) if ( h < 0 || h > 15 ) { - zeek::reporter->InternalWarning("illegal value for encode_hex: %d", h); + reporter->InternalWarning("illegal value for encode_hex: %d", h); return 'X'; } @@ -1612,7 +1612,7 @@ const char* vfmt(const char* format, va_list al) n = vsnprintf(buf, buf_len, format, alc); if ( (unsigned int) n >= buf_len ) - zeek::reporter->InternalError("confusion reformatting in fmt()"); + reporter->InternalError("confusion reformatting in fmt()"); } va_end(alc); @@ -1634,7 +1634,7 @@ bool is_dir(const std::string& path) if ( stat(path.c_str(), &st) < 0 ) { if ( errno != ENOENT ) - zeek::reporter->Warning("can't stat %s: %s", path.c_str(), strerror(errno)); + reporter->Warning("can't stat %s: %s", path.c_str(), strerror(errno)); return false; } @@ -1648,7 +1648,7 @@ bool is_file(const std::string& path) if ( stat(path.c_str(), &st) < 0 ) { if ( errno != ENOENT ) - zeek::reporter->Warning("can't stat %s: %s", path.c_str(), strerror(errno)); + reporter->Warning("can't stat %s: %s", path.c_str(), strerror(errno)); return false; } @@ -1773,7 +1773,7 @@ FILE* open_file(const string& path, const string& mode) { char buf[256]; zeek_strerror_r(errno, buf, sizeof(buf)); - zeek::reporter->Error("Failed to open file %s: %s", filename, buf); + reporter->Error("Failed to open file %s: %s", filename, buf); } return rval; @@ -1819,7 +1819,7 @@ SafeDirname::SafeDirname(const string& path, bool error_aborts) void SafeDirname::DoFunc(const string& path, bool error_aborts) { - char* tmp = zeek::util::copy_string(path.c_str()); + char* tmp = copy_string(path.c_str()); CheckValid(dirname(tmp), tmp, error_aborts); delete [] tmp; } @@ -1838,7 +1838,7 @@ SafeBasename::SafeBasename(const string& path, bool error_aborts) void SafeBasename::DoFunc(const string& path, bool error_aborts) { - char* tmp = zeek::util::copy_string(path.c_str()); + char* tmp = copy_string(path.c_str()); CheckValid(basename(tmp), tmp, error_aborts); delete [] tmp; } @@ -2027,17 +2027,17 @@ double current_time(bool real) { struct timeval tv; if ( gettimeofday(&tv, 0) < 0 ) - zeek::reporter->InternalError("gettimeofday failed in current_time()"); + reporter->InternalError("gettimeofday failed in current_time()"); double t = double(tv.tv_sec) + double(tv.tv_usec) / 1e6; - if ( ! zeek::run_state::pseudo_realtime || real || ! zeek::iosource_mgr || ! zeek::iosource_mgr->GetPktSrc() ) + if ( ! run_state::pseudo_realtime || real || ! iosource_mgr || ! iosource_mgr->GetPktSrc() ) return t; // This obviously only works for a single source ... - zeek::iosource::PktSrc* src = zeek::iosource_mgr->GetPktSrc(); + iosource::PktSrc* src = iosource_mgr->GetPktSrc(); - if ( zeek::run_state::is_processing_suspended() ) + if ( run_state::is_processing_suspended() ) return src->CurrentPacketTimestamp(); // We don't scale with pseudo_realtime here as that would give us a @@ -2095,7 +2095,7 @@ uint64_t calculate_unique_id(size_t pool) uid_pool.resize(pool + 1); else { - zeek::reporter->Warning("pool passed to calculate_unique_id() too large, using default"); + reporter->Warning("pool passed to calculate_unique_id() too large, using default"); pool = UID_POOL_DEFAULT_INTERNAL; } } @@ -2269,7 +2269,7 @@ void* debug_malloc(size_t t) { void* v = malloc(t); if ( malloc_debug ) - printf("%.6f malloc %x %d\n", zeek::run_state::network_time, v, t); + printf("%.6f malloc %x %d\n", run_state::network_time, v, t); return v; } @@ -2277,14 +2277,14 @@ void* debug_realloc(void* v, size_t t) { v = realloc(v, t); if ( malloc_debug ) - printf("%.6f realloc %x %d\n", zeek::run_state::network_time, v, t); + printf("%.6f realloc %x %d\n", run_state::network_time, v, t); return v; } void debug_free(void* v) { if ( malloc_debug ) - printf("%.6f free %x\n", zeek::run_state::network_time, v); + printf("%.6f free %x\n", run_state::network_time, v); free(v); } @@ -2292,7 +2292,7 @@ void* operator new(size_t t) { void* v = malloc(t); if ( malloc_debug ) - printf("%.6f new %x %d\n", zeek::run_state::network_time, v, t); + printf("%.6f new %x %d\n", run_state::network_time, v, t); return v; } @@ -2300,21 +2300,21 @@ void* operator new[](size_t t) { void* v = malloc(t); if ( malloc_debug ) - printf("%.6f new[] %x %d\n", zeek::run_state::network_time, v, t); + printf("%.6f new[] %x %d\n", run_state::network_time, v, t); return v; } void operator delete(void* v) { if ( malloc_debug ) - printf("%.6f delete %x\n", zeek::run_state::network_time, v); + printf("%.6f delete %x\n", run_state::network_time, v); free(v); } void operator delete[](void* v) { if ( malloc_debug ) - printf("%.6f delete %x\n", zeek::run_state::network_time, v); + printf("%.6f delete %x\n", run_state::network_time, v); free(v); } @@ -2392,8 +2392,8 @@ char* zeekenv(const char* name) if ( val && starts_with(it->second, "BRO_") ) { - if ( zeek::reporter ) - zeek::reporter->Warning("Using legacy environment variable %s, support will be removed in Zeek v4.1; use %s instead", it->second, name); + if ( reporter ) + reporter->Warning("Using legacy environment variable %s, support will be removed in Zeek v4.1; use %s instead", it->second, name); else fprintf(stderr, "Using legacy environment variable %s, support will be removed in Zeek v4.1; use %s instead\n", it->second, name); } diff --git a/src/util.h b/src/util.h index 470b144241..f49d841be9 100644 --- a/src/util.h +++ b/src/util.h @@ -316,7 +316,7 @@ void set_processing_status(const char* status, const char* reason); // Renames the given file to a new temporary name, and opens a new file with // the original name. Returns new file or NULL on error. Inits rotate_info if // given (open time is set network time). -extern FILE* rotate_file(const char* name, zeek::RecordVal* rotate_info); +extern FILE* rotate_file(const char* name, RecordVal* rotate_info); // Parse a time string of the form "HH:MM" (as used for the rotation base // time) into a double representing the number of seconds. Returns -1 if the @@ -354,8 +354,8 @@ inline void bytetohex(unsigned char byte, char* hex_out) std::string get_unescaped_string(const std::string& str); -zeek::ODesc* get_escaped_string(zeek::ODesc* d, const char* str, size_t len, - bool escape_all); +ODesc* get_escaped_string(ODesc* d, const char* str, size_t len, + bool escape_all); std::string get_escaped_string(const char* str, size_t len, bool escape_all); inline std::string get_escaped_string(const std::string& str, bool escape_all) @@ -387,7 +387,7 @@ template int atoi_n(int len, const char* s, const char** end, int base, extern char* uitoa_n(uint64_t value, char* str, int n, int base, const char* prefix=nullptr); extern const char* strpbrk_n(size_t len, const char* s, const char* charset); int strstr_n(const int big_len, const unsigned char* big, - const int little_len, const unsigned char* little); + const int little_len, const unsigned char* little); // Replaces all occurences of *o* in *s* with *n*. extern std::string strreplace(const std::string& s, const std::string& o, const std::string& n); diff --git a/src/zeek-setup.cc b/src/zeek-setup.cc index c2f2a8b2b7..0dc969c0ac 100644 --- a/src/zeek-setup.cc +++ b/src/zeek-setup.cc @@ -194,7 +194,7 @@ static std::vector to_cargs(const std::vector& args) static bool show_plugins(int level) { - zeek::plugin::Manager::plugin_list plugins = zeek::plugin_mgr->ActivePlugins(); + plugin::Manager::plugin_list plugins = plugin_mgr->ActivePlugins(); if ( ! plugins.size() ) { @@ -202,14 +202,14 @@ static bool show_plugins(int level) return false; } - zeek::ODesc d; + ODesc d; if ( level == 1 ) d.SetShort(); int count = 0; - for ( zeek::plugin::Manager::plugin_list::const_iterator i = plugins.begin(); i != plugins.end(); i++ ) + for ( plugin::Manager::plugin_list::const_iterator i = plugins.begin(); i != plugins.end(); i++ ) { if ( requested_plugins.size() && requested_plugins.find((*i)->Name()) == requested_plugins.end() ) @@ -225,13 +225,13 @@ static bool show_plugins(int level) printf("%s", d.Description()); - zeek::plugin::Manager::inactive_plugin_list inactives = zeek::plugin_mgr->InactivePlugins(); + plugin::Manager::inactive_plugin_list inactives = plugin_mgr->InactivePlugins(); if ( inactives.size() && ! requested_plugins.size() ) { printf("\nInactive dynamic plugins:\n"); - for ( zeek::plugin::Manager::inactive_plugin_list::const_iterator i = inactives.begin(); i != inactives.end(); i++ ) + for ( plugin::Manager::inactive_plugin_list::const_iterator i = inactives.begin(); i != inactives.end(); i++ ) { string name = (*i).first; string path = (*i).second; @@ -244,32 +244,32 @@ static bool show_plugins(int level) static void done_with_network() { - zeek::util::detail::set_processing_status("TERMINATING", "done_with_network"); + util::detail::set_processing_status("TERMINATING", "done_with_network"); // Cancel any pending alarms (watchdog, in particular). (void) alarm(0); if ( net_done ) { - zeek::event_mgr.Drain(); + event_mgr.Drain(); // Don't propagate this event to remote clients. - zeek::event_mgr.Dispatch( - new zeek::Event(net_done, {zeek::make_intrusive(zeek::detail::timer_mgr->Time())}), + event_mgr.Dispatch( + new Event(net_done, {make_intrusive(timer_mgr->Time())}), true); } - if ( zeek::detail::profiling_logger ) - zeek::detail::profiling_logger->Log(); + if ( profiling_logger ) + profiling_logger->Log(); - zeek::run_state::terminating = true; + run_state::terminating = true; - zeek::analyzer_mgr->Done(); - zeek::detail::timer_mgr->Expire(); - zeek::detail::dns_mgr->Flush(); - zeek::event_mgr.Drain(); - zeek::event_mgr.Drain(); + analyzer_mgr->Done(); + timer_mgr->Expire(); + dns_mgr->Flush(); + event_mgr.Drain(); + event_mgr.Drain(); - zeek::run_state::detail::finish_run(1); + run_state::detail::finish_run(1); #ifdef USE_PERFTOOLS_DEBUG @@ -291,78 +291,78 @@ static void done_with_network() static void terminate_bro() { - zeek::util::detail::set_processing_status("TERMINATING", "terminate_bro"); + util::detail::set_processing_status("TERMINATING", "terminate_bro"); - zeek::run_state::terminating = true; + run_state::terminating = true; - zeek::iosource_mgr->Wakeup("terminate_bro"); + iosource_mgr->Wakeup("terminate_bro"); // File analysis termination may produce events, so do it early on in // the termination process. - zeek::file_mgr->Terminate(); + file_mgr->Terminate(); - zeek::detail::script_coverage_mgr.WriteStats(); + script_coverage_mgr.WriteStats(); if ( zeek_done ) - zeek::event_mgr.Enqueue(zeek_done, zeek::Args{}); + event_mgr.Enqueue(zeek_done, Args{}); - zeek::detail::timer_mgr->Expire(); - zeek::event_mgr.Drain(); + timer_mgr->Expire(); + event_mgr.Drain(); - if ( zeek::detail::profiling_logger ) + if ( profiling_logger ) { // FIXME: There are some occasional crashes in the memory // allocation code when killing Bro. Disabling this for now. if ( ! (signal_val == SIGTERM || signal_val == SIGINT) ) - zeek::detail::profiling_logger->Log(); + profiling_logger->Log(); - delete zeek::detail::profiling_logger; + delete profiling_logger; } - zeek::event_mgr.Drain(); + event_mgr.Drain(); - zeek::notifier::detail::registry.Terminate(); - zeek::log_mgr->Terminate(); - zeek::input_mgr->Terminate(); - zeek::thread_mgr->Terminate(); - zeek::broker_mgr->Terminate(); - zeek::detail::dns_mgr->Terminate(); + notifier::detail::registry.Terminate(); + log_mgr->Terminate(); + input_mgr->Terminate(); + thread_mgr->Terminate(); + broker_mgr->Terminate(); + dns_mgr->Terminate(); - zeek::event_mgr.Drain(); + event_mgr.Drain(); - zeek::plugin_mgr->FinishPlugins(); + plugin_mgr->FinishPlugins(); - delete zeek::detail::zeekygen_mgr; - delete zeek::analyzer_mgr; - delete zeek::file_mgr; + delete zeekygen_mgr; + delete analyzer_mgr; + delete file_mgr; // broker_mgr, timer_mgr, and supervisor are deleted via iosource_mgr - delete zeek::iosource_mgr; - delete zeek::event_registry; - delete zeek::log_mgr; - delete zeek::reporter; - delete zeek::plugin_mgr; - delete zeek::val_mgr; + delete iosource_mgr; + delete event_registry; + delete log_mgr; + delete reporter; + delete plugin_mgr; + delete val_mgr; // free the global scope - zeek::detail::pop_scope(); + pop_scope(); - zeek::reporter = nullptr; + reporter = nullptr; } RETSIGTYPE sig_handler(int signo) { - zeek::util::detail::set_processing_status("TERMINATING", "sig_handler"); + util::detail::set_processing_status("TERMINATING", "sig_handler"); signal_val = signo; - if ( ! zeek::run_state::terminating ) - zeek::iosource_mgr->Wakeup("sig_handler"); + if ( ! run_state::terminating ) + iosource_mgr->Wakeup("sig_handler"); return RETSIGVAL; } static void atexit_handler() { - zeek::util::detail::set_processing_status("TERMINATED", "atexit"); + util::detail::set_processing_status("TERMINATED", "atexit"); } static void bro_new_handler() @@ -376,7 +376,7 @@ static std::vector get_script_signature_files() // Parse rule files defined on the script level. char* script_signature_files = - zeek::util::copy_string(zeek::id::find_val("signature_files")->AsString()->CheckString()); + util::copy_string(id::find_val("signature_files")->AsString()->CheckString()); char* tmp = script_signature_files; char* s; @@ -388,13 +388,13 @@ static std::vector get_script_signature_files() return rval; } -zeek::detail::SetupResult setup(int argc, char** argv, - zeek::Options* zopts) +SetupResult setup(int argc, char** argv, + Options* zopts) { ZEEK_LSAN_DISABLE(); std::set_new_handler(bro_new_handler); - auto zeek_exe_path = zeek::util::detail::get_exe_path(argv[0]); + auto zeek_exe_path = util::detail::get_exe_path(argv[0]); if ( zeek_exe_path.empty() ) { @@ -406,12 +406,12 @@ zeek::detail::SetupResult setup(int argc, char** argv, zeek_argv = new char* [argc]; for ( int i = 0; i < argc; i++ ) - zeek_argv[i] = zeek::util::copy_string(argv[i]); + zeek_argv[i] = util::copy_string(argv[i]); - auto options = zopts ? *zopts : zeek::parse_cmdline(argc, argv); + auto options = zopts ? *zopts : parse_cmdline(argc, argv); if ( options.print_usage ) - zeek::usage(argv[0], 0); + usage(argv[0], 0); if ( options.print_version ) { @@ -428,27 +428,27 @@ zeek::detail::SetupResult setup(int argc, char** argv, exit(context.run()); } - auto stem = zeek::Supervisor::CreateStem(options.supervisor_mode); + auto stem = Supervisor::CreateStem(options.supervisor_mode); - if ( zeek::Supervisor::ThisNode() ) - zeek::Supervisor::ThisNode()->Init(&options); + if ( Supervisor::ThisNode() ) + Supervisor::ThisNode()->Init(&options); - zeek::detail::script_coverage_mgr.ReadStats(); + script_coverage_mgr.ReadStats(); auto dns_type = options.dns_mode; - if ( dns_type == DNS_DEFAULT && zeek::fake_dns() ) + if ( dns_type == DNS_DEFAULT && fake_dns() ) dns_type = DNS_FAKE; RETSIGTYPE (*oldhandler)(int); zeek_script_prefixes = options.script_prefixes; - auto zeek_prefixes = zeek::util::zeekenv("ZEEK_PREFIXES"); + auto zeek_prefixes = util::zeekenv("ZEEK_PREFIXES"); if ( zeek_prefixes ) - zeek::util::tokenize_string(zeek_prefixes, ":", &zeek_script_prefixes); + util::tokenize_string(zeek_prefixes, ":", &zeek_script_prefixes); - zeek::run_state::pseudo_realtime = options.pseudo_realtime; + run_state::pseudo_realtime = options.pseudo_realtime; #ifdef USE_PERFTOOLS_DEBUG perftools_leaks = options.perftools_check_leaks; @@ -471,17 +471,17 @@ zeek::detail::SetupResult setup(int argc, char** argv, } if ( options.process_status_file ) - proc_status_file = zeek::util::copy_string(options.process_status_file->data()); + proc_status_file = util::copy_string(options.process_status_file->data()); atexit(atexit_handler); - zeek::util::detail::set_processing_status("INITIALIZING", "main"); + util::detail::set_processing_status("INITIALIZING", "main"); - zeek::run_state::zeek_start_time = zeek::util::current_time(true); + run_state::zeek_start_time = util::current_time(true); - zeek::val_mgr = new ValManager(); + val_mgr = new ValManager(); reporter = new Reporter(options.abort_on_scripting_errors); - zeek::thread_mgr = new threading::Manager(); - zeek::plugin_mgr = new zeek::plugin::Manager(); + thread_mgr = new threading::Manager(); + plugin_mgr = new plugin::Manager(); #ifdef DEBUG if ( options.debug_log_streams ) @@ -497,20 +497,20 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( options.supervisor_mode ) { - zeek::Supervisor::Config cfg = {}; + Supervisor::Config cfg = {}; cfg.zeek_exe_path = zeek_exe_path; options.filter_supervisor_options(); - zeek::supervisor_mgr = new zeek::Supervisor(std::move(cfg), std::move(*stem)); + supervisor_mgr = new Supervisor(std::move(cfg), std::move(*stem)); } - const char* seed_load_file = zeek::util::zeekenv("ZEEK_SEED_FILE"); + const char* seed_load_file = util::zeekenv("ZEEK_SEED_FILE"); if ( options.random_seed_input_file ) seed_load_file = options.random_seed_input_file->data(); - zeek::util::detail::init_random_seed((seed_load_file && *seed_load_file ? seed_load_file : nullptr), - options.random_seed_output_file ? options.random_seed_output_file->data() : nullptr, - options.deterministic_mode); + util::detail::init_random_seed((seed_load_file && *seed_load_file ? seed_load_file : nullptr), + options.random_seed_output_file ? options.random_seed_output_file->data() : nullptr, + options.deterministic_mode); // DEBUG_MSG("HMAC key: %s\n", md5_digest_print(shared_hmac_md5_key)); init_hash_function(); @@ -526,7 +526,7 @@ zeek::detail::SetupResult setup(int argc, char** argv, int r = sqlite3_initialize(); if ( r != SQLITE_OK ) - zeek::reporter->Error("Failed to initialize sqlite3: %s", sqlite3_errstr(r)); + reporter->Error("Failed to initialize sqlite3: %s", sqlite3_errstr(r)); #ifdef USE_IDMEF char* libidmef_dtd_path_cstr = new char[options.libidmef_dtd_file.size() + 1]; @@ -536,10 +536,10 @@ zeek::detail::SetupResult setup(int argc, char** argv, createCurrentDoc("1.0"); // Set a global XML document #endif - zeek::detail::timer_mgr = new zeek::detail::PQ_TimerMgr(); + timer_mgr = new PQ_TimerMgr(); auto zeekygen_cfg = options.zeekygen_config_file.value_or(""); - zeek::detail::zeekygen_mgr = new zeek::zeekygen::detail::Manager(zeekygen_cfg, zeek_argv[0]); + zeekygen_mgr = new zeekygen::detail::Manager(zeekygen_cfg, zeek_argv[0]); add_essential_input_file("base/init-bare.zeek"); add_essential_input_file("base/init-frameworks-and-bifs.zeek"); @@ -547,14 +547,14 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( ! options.bare_mode ) add_input_file("base/init-default.zeek"); - zeek::plugin_mgr->SearchDynamicPlugins(zeek::util::zeek_plugin_path()); + plugin_mgr->SearchDynamicPlugins(util::zeek_plugin_path()); if ( options.plugins_to_load.empty() && options.scripts_to_load.empty() && options.script_options_to_set.empty() && ! options.pcap_file && ! options.interface && ! options.identifier_to_print && ! command_line_policy && ! options.print_plugins && - ! options.supervisor_mode && ! zeek::Supervisor::ThisNode() ) + ! options.supervisor_mode && ! Supervisor::ThisNode() ) add_input_file("-"); for ( const auto& script_option : options.script_options_to_set ) @@ -568,54 +568,54 @@ zeek::detail::SetupResult setup(int argc, char** argv, push_scope(nullptr, nullptr); - zeek::detail::dns_mgr = new zeek::detail::DNS_Mgr(dns_type); + dns_mgr = new DNS_Mgr(dns_type); // It would nice if this were configurable. This is similar to the // chicken and the egg problem. It would be configurable by parsing // policy, but we can't parse policy without DNS resolution. - zeek::detail::dns_mgr->SetDir(".state"); + dns_mgr->SetDir(".state"); - zeek::iosource_mgr = new iosource::Manager(); - zeek::event_registry = new EventRegistry(); - zeek::analyzer_mgr = new analyzer::Manager(); - zeek::log_mgr = new logging::Manager(); - zeek::input_mgr = new input::Manager(); - zeek::file_mgr = new file_analysis::Manager(); + iosource_mgr = new iosource::Manager(); + event_registry = new EventRegistry(); + analyzer_mgr = new analyzer::Manager(); + log_mgr = new logging::Manager(); + input_mgr = new input::Manager(); + file_mgr = new file_analysis::Manager(); auto broker_real_time = ! options.pcap_file && ! options.deterministic_mode; - zeek::broker_mgr = new zeek::Broker::Manager(broker_real_time); - zeek::detail::trigger_mgr = new zeek::detail::trigger::Manager(); + broker_mgr = new Broker::Manager(broker_real_time); + trigger_mgr = new trigger::Manager(); - zeek::plugin_mgr->InitPreScript(); - zeek::analyzer_mgr->InitPreScript(); - zeek::file_mgr->InitPreScript(); - zeek::detail::zeekygen_mgr->InitPreScript(); + plugin_mgr->InitPreScript(); + analyzer_mgr->InitPreScript(); + file_mgr->InitPreScript(); + zeekygen_mgr->InitPreScript(); bool missing_plugin = false; for ( set::const_iterator i = requested_plugins.begin(); i != requested_plugins.end(); i++ ) { - if ( ! zeek::plugin_mgr->ActivateDynamicPlugin(*i) ) + if ( ! plugin_mgr->ActivateDynamicPlugin(*i) ) missing_plugin = true; } if ( missing_plugin ) - zeek::reporter->FatalError("Failed to activate requested dynamic plugin(s)."); + reporter->FatalError("Failed to activate requested dynamic plugin(s)."); - zeek::plugin_mgr->ActivateDynamicPlugins(! options.bare_mode); + plugin_mgr->ActivateDynamicPlugins(! options.bare_mode); init_event_handlers(); - md5_type = zeek::make_intrusive("md5"); - sha1_type = zeek::make_intrusive("sha1"); - sha256_type = zeek::make_intrusive("sha256"); - entropy_type = zeek::make_intrusive("entropy"); - cardinality_type = zeek::make_intrusive("cardinality"); - topk_type = zeek::make_intrusive("topk"); - bloomfilter_type = zeek::make_intrusive("bloomfilter"); - x509_opaque_type = zeek::make_intrusive("x509"); - ocsp_resp_opaque_type = zeek::make_intrusive("ocsp_resp"); - paraglob_type = zeek::make_intrusive("paraglob"); + md5_type = make_intrusive("md5"); + sha1_type = make_intrusive("sha1"); + sha256_type = make_intrusive("sha256"); + entropy_type = make_intrusive("entropy"); + cardinality_type = make_intrusive("cardinality"); + topk_type = make_intrusive("topk"); + bloomfilter_type = make_intrusive("bloomfilter"); + x509_opaque_type = make_intrusive("x509"); + ocsp_resp_opaque_type = make_intrusive("ocsp_resp"); + paraglob_type = make_intrusive("paraglob"); // The leak-checker tends to produce some false // positives (memory which had already been @@ -628,9 +628,9 @@ zeek::detail::SetupResult setup(int argc, char** argv, HeapLeakChecker::Disabler disabler; #endif - zeek::run_state::is_parsing = true; + run_state::is_parsing = true; yyparse(); - zeek::run_state::is_parsing = false; + run_state::is_parsing = false; RecordVal::DoneParsing(); TableVal::DoneParsing(); @@ -650,21 +650,21 @@ zeek::detail::SetupResult setup(int argc, char** argv, "BinPAC::flowbuffer_contract_threshold")->GetVal()->AsCount(); binpac::init(&flowbuffer_policy); - zeek::plugin_mgr->InitBifs(); + plugin_mgr->InitBifs(); - if ( zeek::reporter->Errors() > 0 ) + if ( reporter->Errors() > 0 ) exit(1); - zeek::iosource_mgr->InitPostScript(); - zeek::log_mgr->InitPostScript(); - zeek::plugin_mgr->InitPostScript(); - zeek::detail::zeekygen_mgr->InitPostScript(); - zeek::broker_mgr->InitPostScript(); - zeek::detail::timer_mgr->InitPostScript(); - zeek::event_mgr.InitPostScript(); + iosource_mgr->InitPostScript(); + log_mgr->InitPostScript(); + plugin_mgr->InitPostScript(); + zeekygen_mgr->InitPostScript(); + broker_mgr->InitPostScript(); + timer_mgr->InitPostScript(); + event_mgr.InitPostScript(); - if ( zeek::supervisor_mgr ) - zeek::supervisor_mgr->InitPostScript(); + if ( supervisor_mgr ) + supervisor_mgr->InitPostScript(); if ( options.print_plugins ) { @@ -672,13 +672,13 @@ zeek::detail::SetupResult setup(int argc, char** argv, exit(success ? 0 : 1); } - zeek::analyzer_mgr->InitPostScript(); - zeek::file_mgr->InitPostScript(); - zeek::detail::dns_mgr->InitPostScript(); + analyzer_mgr->InitPostScript(); + file_mgr->InitPostScript(); + dns_mgr->InitPostScript(); if ( options.parse_only ) { - int rc = (zeek::reporter->Errors() > 0 ? 1 : 0); + int rc = (reporter->Errors() > 0 ? 1 : 0); exit(rc); } @@ -686,24 +686,24 @@ zeek::detail::SetupResult setup(int argc, char** argv, } #endif - if ( zeek::reporter->Errors() > 0 ) + if ( reporter->Errors() > 0 ) { - delete zeek::detail::dns_mgr; + delete dns_mgr; exit(1); } - zeek::reporter->InitOptions(); + reporter->InitOptions(); KeyedHash::InitOptions(); - zeek::detail::zeekygen_mgr->GenerateDocs(); + zeekygen_mgr->GenerateDocs(); if ( options.pcap_filter ) { const auto& id = global_scope()->Find("cmd_line_bpf_filter"); if ( ! id ) - zeek::reporter->InternalError("global cmd_line_bpf_filter not defined"); + reporter->InternalError("global cmd_line_bpf_filter not defined"); - id->SetVal(zeek::make_intrusive(*options.pcap_filter)); + id->SetVal(make_intrusive(*options.pcap_filter)); } auto all_signature_files = options.signature_files; @@ -721,14 +721,14 @@ zeek::detail::SetupResult setup(int argc, char** argv, rule_matcher = new RuleMatcher(options.signature_re_level); if ( ! rule_matcher->ReadFiles(all_signature_files) ) { - delete zeek::detail::dns_mgr; + delete dns_mgr; exit(1); } if ( options.print_signature_debug_info ) rule_matcher->PrintDebug(); - zeek::file_mgr->InitMagic(); + file_mgr->InitMagic(); } if ( g_policy_debug ) @@ -737,7 +737,7 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( ! options.pcap_file && ! options.interface ) { - const auto& interfaces_val = zeek::id::find_val("interfaces"); + const auto& interfaces_val = id::find_val("interfaces"); if ( interfaces_val ) { char* interfaces_str = @@ -751,7 +751,7 @@ zeek::detail::SetupResult setup(int argc, char** argv, } if ( dns_type != DNS_PRIME ) - zeek::run_state::detail::init_run(options.interface, options.pcap_file, options.pcap_output_file, options.use_watchdog); + run_state::detail::init_run(options.interface, options.pcap_file, options.pcap_output_file, options.use_watchdog); if ( ! g_policy_debug ) { @@ -766,14 +766,14 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( dns_type == DNS_PRIME ) { - zeek::detail::dns_mgr->Verify(); - zeek::detail::dns_mgr->Resolve(); + dns_mgr->Verify(); + dns_mgr->Resolve(); - if ( ! zeek::detail::dns_mgr->Save() ) - zeek::reporter->FatalError("can't update DNS cache"); + if ( ! dns_mgr->Save() ) + reporter->FatalError("can't update DNS cache"); - zeek::event_mgr.Drain(); - delete zeek::detail::dns_mgr; + event_mgr.Drain(); + delete dns_mgr; exit(0); } @@ -782,9 +782,9 @@ zeek::detail::SetupResult setup(int argc, char** argv, { const auto& id = global_scope()->Find(*options.identifier_to_print); if ( ! id ) - zeek::reporter->FatalError("No such ID: %s\n", options.identifier_to_print->data()); + reporter->FatalError("No such ID: %s\n", options.identifier_to_print->data()); - zeek::ODesc desc; + ODesc desc; desc.SetQuotes(true); desc.SetIncludeStats(true); id->DescribeExtended(&desc); @@ -795,29 +795,29 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( profiling_interval > 0 ) { - const auto& profiling_file = zeek::id::find_val("profiling_file"); - zeek::detail::profiling_logger = new ProfileLogger(profiling_file->AsFile(), + const auto& profiling_file = id::find_val("profiling_file"); + profiling_logger = new ProfileLogger(profiling_file->AsFile(), profiling_interval); if ( segment_profiling ) - zeek::detail::segment_logger = zeek::detail::profiling_logger; + segment_logger = profiling_logger; } - if ( ! zeek::run_state::reading_live && ! zeek::run_state::reading_traces ) + if ( ! run_state::reading_live && ! run_state::reading_traces ) // Set up network_time to track real-time, since // we don't have any other source for it. - zeek::run_state::detail::update_network_time(zeek::util::current_time()); + run_state::detail::update_network_time(util::current_time()); if ( zeek_init ) - zeek::event_mgr.Enqueue(zeek_init, zeek::Args{}); + event_mgr.Enqueue(zeek_init, Args{}); EventRegistry::string_list dead_handlers = - zeek::event_registry->UnusedHandlers(); + event_registry->UnusedHandlers(); if ( ! dead_handlers.empty() && check_for_unused_event_handlers ) { for ( const string& handler : dead_handlers ) - zeek::reporter->Warning("event handler never invoked: %s", handler.c_str()); + reporter->Warning("event handler never invoked: %s", handler.c_str()); } // Enable LeakSanitizer before zeek_init() and even before executing @@ -839,7 +839,7 @@ zeek::detail::SetupResult setup(int argc, char** argv, } catch ( InterpreterException& ) { - zeek::reporter->FatalError("failed to execute script statements at top-level scope"); + reporter->FatalError("failed to execute script statements at top-level scope"); } g_frame_stack.pop_back(); @@ -856,25 +856,25 @@ zeek::detail::SetupResult setup(int argc, char** argv, if ( file.skipped ) continue; - zeek::event_mgr.Enqueue(zeek_script_loaded, - zeek::make_intrusive(file.name.c_str()), - zeek::val_mgr->Count(file.include_level)); + event_mgr.Enqueue(zeek_script_loaded, + make_intrusive(file.name.c_str()), + val_mgr->Count(file.include_level)); } } - zeek::reporter->ReportViaEvents(true); + reporter->ReportViaEvents(true); // Drain the event queue here to support the protocols framework configuring DPM - zeek::event_mgr.Drain(); + event_mgr.Drain(); - if ( zeek::reporter->Errors() > 0 && ! zeek::util::zeekenv("ZEEK_ALLOW_INIT_ERRORS") ) - zeek::reporter->FatalError("errors occurred while initializing"); + if ( reporter->Errors() > 0 && ! util::zeekenv("ZEEK_ALLOW_INIT_ERRORS") ) + reporter->FatalError("errors occurred while initializing"); - zeek::broker_mgr->ZeekInitDone(); - zeek::reporter->ZeekInitDone(); - zeek::analyzer_mgr->DumpDebug(); + broker_mgr->ZeekInitDone(); + reporter->ZeekInitDone(); + analyzer_mgr->DumpDebug(); - zeek::run_state::detail::have_pending_timers = ! zeek::run_state::reading_traces && zeek::detail::timer_mgr->Size() > 0; + run_state::detail::have_pending_timers = ! run_state::reading_traces && timer_mgr->Size() > 0; return {0, std::move(options)}; } @@ -884,7 +884,7 @@ int cleanup(bool did_net_run) if ( did_net_run ) done_with_network(); - zeek::run_state::detail::delete_run(); + run_state::detail::delete_run(); terminate_bro(); sqlite3_shutdown(); @@ -895,7 +895,7 @@ int cleanup(bool did_net_run) // Close files after net_delete(), because net_delete() // might write to connection content files. - zeek::File::CloseOpenFiles(); + File::CloseOpenFiles(); delete rule_matcher; @@ -908,8 +908,8 @@ namespace run_state::detail { void zeek_terminate_loop(const char* reason) { - zeek::util::detail::set_processing_status("TERMINATING", reason); - zeek::reporter->Info("%s", reason); + util::detail::set_processing_status("TERMINATING", reason); + reporter->Info("%s", reason); get_final_stats(); zeek::detail::done_with_network(); @@ -919,7 +919,7 @@ void zeek_terminate_loop(const char* reason) // Close files after net_delete(), because net_delete() // might write to connection content files. - zeek::File::CloseOpenFiles(); + File::CloseOpenFiles(); delete zeek::detail::rule_matcher; diff --git a/src/zeek-setup.h b/src/zeek-setup.h index 89333ac673..4b32772275 100644 --- a/src/zeek-setup.h +++ b/src/zeek-setup.h @@ -8,7 +8,7 @@ namespace zeek::detail { struct SetupResult { int code = 0; - zeek::Options options; + Options options; }; /** @@ -20,7 +20,7 @@ struct SetupResult { * needs to be provided regardless since some functionality requires * it, particularly, several things use the value of argv[0]. */ -SetupResult setup(int argc, char** argv, zeek::Options* options = nullptr); +SetupResult setup(int argc, char** argv, Options* options = nullptr); /** * Cleans up Zeek's global state. diff --git a/src/zeekygen/Configuration.cc b/src/zeekygen/Configuration.cc index d8fe3e8bc0..fad29f80b0 100644 --- a/src/zeekygen/Configuration.cc +++ b/src/zeekygen/Configuration.cc @@ -37,8 +37,8 @@ Config::Config(const string& arg_file, const string& delim) ifstream f(file.c_str()); if ( ! f.is_open() ) - zeek::reporter->FatalError("failed to open Zeekygen config file '%s': %s", - file.c_str(), strerror(errno)); + reporter->FatalError("failed to open Zeekygen config file '%s': %s", + file.c_str(), strerror(errno)); string line; unsigned int line_number = 0; @@ -47,7 +47,7 @@ Config::Config(const string& arg_file, const string& delim) { ++line_number; vector tokens; - zeek::util::tokenize_string(line, delim, &tokens); + util::tokenize_string(line, delim, &tokens); tokens.erase(remove(tokens.begin(), tokens.end(), ""), tokens.end()); if ( tokens.empty() ) @@ -59,21 +59,21 @@ Config::Config(const string& arg_file, const string& delim) continue; if ( tokens.size() != 3 ) - zeek::reporter->FatalError("malformed Zeekygen target in %s:%u: %s", - file.c_str(), line_number, line.c_str()); + reporter->FatalError("malformed Zeekygen target in %s:%u: %s", + file.c_str(), line_number, line.c_str()); Target* target = target_factory.Create(tokens[0], tokens[2], tokens[1]); if ( ! target ) - zeek::reporter->FatalError("unknown Zeekygen target type: %s", - tokens[0].c_str()); + reporter->FatalError("unknown Zeekygen target type: %s", + tokens[0].c_str()); targets.push_back(target); } if ( f.bad() ) - zeek::reporter->InternalError("error reading Zeekygen config file '%s': %s", - file.c_str(), strerror(errno)); + reporter->InternalError("error reading Zeekygen config file '%s': %s", + file.c_str(), strerror(errno)); } Config::~Config() diff --git a/src/zeekygen/IdentifierInfo.cc b/src/zeekygen/IdentifierInfo.cc index 5e7f8520ee..5946432778 100644 --- a/src/zeekygen/IdentifierInfo.cc +++ b/src/zeekygen/IdentifierInfo.cc @@ -39,12 +39,12 @@ void IdentifierInfo::AddRedef(const string& script, zeek::detail::InitClass ic, redefs.push_back(redef); } -void IdentifierInfo::AddRecordField(const zeek::TypeDecl* field, +void IdentifierInfo::AddRecordField(const TypeDecl* field, const string& script, vector& comments) { RecordField* rf = new RecordField(); - rf->field = new zeek::TypeDecl(*field); + rf->field = new TypeDecl(*field); rf->from_script = script; rf->comments = comments; @@ -101,7 +101,7 @@ string IdentifierInfo::GetDeclaringScriptForField(const string& field) const string IdentifierInfo::DoReStructuredText(bool roles_only) const { - zeek::ODesc d; + ODesc d; d.SetIndentSpaces(3); d.SetQuotes(true); id->DescribeReST(&d, roles_only); @@ -117,7 +117,7 @@ string IdentifierInfo::DoReStructuredText(bool roles_only) const if ( i > 0 ) d.NL(); - if ( zeek::IsFunc(id->GetType()->Tag()) ) + if ( IsFunc(id->GetType()->Tag()) ) { string s = comments[i]; diff --git a/src/zeekygen/IdentifierInfo.h b/src/zeekygen/IdentifierInfo.h index 79f4ee8596..c04aa9f206 100644 --- a/src/zeekygen/IdentifierInfo.h +++ b/src/zeekygen/IdentifierInfo.h @@ -42,7 +42,7 @@ public: /** * Returns the initial value of the identifier. */ - const zeek::ValPtr& InitialVal() const + const ValPtr& InitialVal() const { return initial_val; } /** @@ -82,7 +82,7 @@ public: * differ from the script in which a record type is declared due to redefs. * @param comments Comments associated with the record field. */ - void AddRecordField(const zeek::TypeDecl* field, const std::string& script, + void AddRecordField(const TypeDecl* field, const std::string& script, std::vector& comments); /** @@ -165,7 +165,7 @@ private: struct RecordField { ~RecordField(); - zeek::TypeDecl* field; + TypeDecl* field; std::string from_script; std::vector comments; }; @@ -175,7 +175,7 @@ private: std::vector comments; zeek::detail::IDPtr id; - zeek::ValPtr initial_val; + ValPtr initial_val; redef_list redefs; record_field_map fields; RecordField* last_field_seen; diff --git a/src/zeekygen/Manager.cc b/src/zeekygen/Manager.cc index 8971679725..285edc8fb7 100644 --- a/src/zeekygen/Manager.cc +++ b/src/zeekygen/Manager.cc @@ -19,14 +19,14 @@ namespace zeek::zeekygen::detail { static void DbgAndWarn(const char* msg) { - if ( zeek::reporter->Errors() ) + if ( reporter->Errors() ) // We've likely already reported to real source of the problem // as an error, avoid adding an additional warning which may // be confusing. return; - zeek::reporter->Warning("%s", msg); - DBG_LOG(zeek::DBG_ZEEKYGEN, "%s", msg); + reporter->Warning("%s", msg); + DBG_LOG(DBG_ZEEKYGEN, "%s", msg); } static void WarnMissingScript(const char* type, const zeek::detail::ID* id, @@ -35,9 +35,9 @@ static void WarnMissingScript(const char* type, const zeek::detail::ID* id, if ( script == "" ) return; - DbgAndWarn(zeek::util::fmt("Can't generate Zeekygen doumentation for %s %s, " - "lookup of %s failed", - type, id->Name(), script.c_str())); + DbgAndWarn(util::fmt("Can't generate Zeekygen doumentation for %s %s, " + "lookup of %s failed", + type, id->Name(), script.c_str())); } static string RemoveLeadingSpace(const string& s) @@ -56,14 +56,14 @@ static string RemoveLeadingSpace(const string& s) // use for indexing. static string NormalizeScriptPath(const string& path) { - if ( auto p = zeek::plugin_mgr->LookupPluginByPath(path) ) + if ( auto p = plugin_mgr->LookupPluginByPath(path) ) { - auto rval = zeek::util::detail::normalize_path(path); - auto prefix = zeek::util::SafeBasename(p->PluginDirectory()).result; + auto rval = util::detail::normalize_path(path); + auto prefix = util::SafeBasename(p->PluginDirectory()).result; return prefix + "/" + rval.substr(p->PluginDirectory().size() + 1); } - return zeek::util::detail::without_zeekpath_component(path); + return util::detail::without_zeekpath_component(path); } Manager::Manager(const string& arg_config, const string& bro_command) @@ -71,7 +71,7 @@ Manager::Manager(const string& arg_config, const string& bro_command) identifiers(), all_info(), last_identifier_seen(), incomplete_type(), enum_mappings(), config(arg_config), bro_mtime() { - if ( zeek::util::zeekenv("ZEEK_DISABLE_ZEEKYGEN") ) + if ( util::zeekenv("ZEEK_DISABLE_ZEEKYGEN") ) disabled = true; // If running bro without the "-X" option, then we don't need bro_mtime. @@ -83,14 +83,14 @@ Manager::Manager(const string& arg_config, const string& bro_command) // bro_command is a relative path). const char* env_path = getenv("PATH"); string path = env_path ? string(env_path) + ":." : "."; - string path_to_bro = zeek::util::find_file(bro_command, path); + string path_to_bro = util::find_file(bro_command, path); struct stat s; // One way that find_file() could fail is when bro is located in // a PATH component that starts with a tilde (such as "~/bin"). A simple // workaround is to just run bro with a relative or absolute path. if ( path_to_bro.empty() || stat(path_to_bro.c_str(), &s) < 0 ) - zeek::reporter->InternalError( + reporter->InternalError( "Zeekygen can't get mtime of zeek binary %s (try again by specifying the absolute or relative path to Zeek): %s", path_to_bro.c_str(), strerror(errno)); @@ -139,32 +139,32 @@ void Manager::Script(const string& path) if ( scripts.GetInfo(name) ) { - DbgAndWarn(zeek::util::fmt("Duplicate Zeekygen script documentation: %s", - name.c_str())); + DbgAndWarn(util::fmt("Duplicate Zeekygen script documentation: %s", + name.c_str())); return; } ScriptInfo* info = new ScriptInfo(name, path); scripts.map[name] = info; all_info.push_back(info); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Made ScriptInfo %s", name.c_str()); + DBG_LOG(DBG_ZEEKYGEN, "Made ScriptInfo %s", name.c_str()); if ( ! info->IsPkgLoader() ) return; - name = zeek::util::SafeDirname(name).result; + name = util::SafeDirname(name).result; if ( packages.GetInfo(name) ) { - DbgAndWarn(zeek::util::fmt("Duplicate Zeekygen package documentation: %s", - name.c_str())); + DbgAndWarn(util::fmt("Duplicate Zeekygen package documentation: %s", + name.c_str())); return; } PackageInfo* pkginfo = new PackageInfo(name); packages.map[name] = pkginfo; all_info.push_back(pkginfo); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Made PackageInfo %s", name.c_str()); + DBG_LOG(DBG_ZEEKYGEN, "Made PackageInfo %s", name.c_str()); } void Manager::ScriptDependency(const string& path, const string& dep) @@ -174,8 +174,8 @@ void Manager::ScriptDependency(const string& path, const string& dep) if ( dep.empty() ) { - DbgAndWarn(zeek::util::fmt("Empty Zeekygen script doc dependency: %s", - path.c_str())); + DbgAndWarn(util::fmt("Empty Zeekygen script doc dependency: %s", + path.c_str())); return; } @@ -185,18 +185,18 @@ void Manager::ScriptDependency(const string& path, const string& dep) if ( ! script_info ) { - DbgAndWarn(zeek::util::fmt("Failed to add Zeekygen script doc dependency %s " - "for %s", depname.c_str(), name.c_str())); + DbgAndWarn(util::fmt("Failed to add Zeekygen script doc dependency %s " + "for %s", depname.c_str(), name.c_str())); return; } script_info->AddDependency(depname); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Added script dependency %s for %s", + DBG_LOG(DBG_ZEEKYGEN, "Added script dependency %s for %s", depname.c_str(), name.c_str()); for ( size_t i = 0; i < comment_buffer.size(); ++i ) - DbgAndWarn(zeek::util::fmt("Discarded extraneous Zeekygen comment: %s", - comment_buffer[i].c_str())); + DbgAndWarn(util::fmt("Discarded extraneous Zeekygen comment: %s", + comment_buffer[i].c_str())); } void Manager::ModuleUsage(const string& path, const string& module) @@ -209,13 +209,13 @@ void Manager::ModuleUsage(const string& path, const string& module) if ( ! script_info ) { - DbgAndWarn(zeek::util::fmt("Failed to add Zeekygen module usage %s in %s", - module.c_str(), name.c_str())); + DbgAndWarn(util::fmt("Failed to add Zeekygen module usage %s in %s", + module.c_str(), name.c_str())); return; } script_info->AddModule(module); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Added module usage %s in %s", + DBG_LOG(DBG_ZEEKYGEN, "Added module usage %s in %s", module.c_str(), name.c_str()); } @@ -257,8 +257,8 @@ void Manager::StartType(zeek::detail::IDPtr id) if ( id->GetLocationInfo() == &zeek::detail::no_location ) { - DbgAndWarn(zeek::util::fmt("Can't generate zeekygen doumentation for %s, " - "no location available", id->Name())); + DbgAndWarn(util::fmt("Can't generate zeekygen doumentation for %s, " + "no location available", id->Name())); return; } @@ -271,14 +271,14 @@ void Manager::StartType(zeek::detail::IDPtr id) return; } - DBG_LOG(zeek::DBG_ZEEKYGEN, "Making IdentifierInfo (incomplete) %s, in %s", + DBG_LOG(DBG_ZEEKYGEN, "Making IdentifierInfo (incomplete) %s, in %s", id->Name(), script.c_str()); incomplete_type = CreateIdentifierInfo(std::move(id), script_info); } static bool IsEnumType(zeek::detail::ID* id) { - return id->IsType() ? id->GetType()->Tag() == zeek::TYPE_ENUM : false; + return id->IsType() ? id->GetType()->Tag() == TYPE_ENUM : false; } void Manager::Identifier(zeek::detail::IDPtr id) @@ -290,7 +290,7 @@ void Manager::Identifier(zeek::detail::IDPtr id) { if ( incomplete_type->Name() == id->Name() ) { - DBG_LOG(zeek::DBG_ZEEKYGEN, "Finished document for type %s", id->Name()); + DBG_LOG(DBG_ZEEKYGEN, "Finished document for type %s", id->Name()); incomplete_type->CompletedTypeDecl(); incomplete_type = nullptr; return; @@ -304,7 +304,7 @@ void Manager::Identifier(zeek::detail::IDPtr id) if ( id_info ) { - if ( zeek::IsFunc(id_info->GetID()->GetType()->Tag()) ) + if ( IsFunc(id_info->GetID()->GetType()->Tag()) ) { // Function may already been seen (declaration versus body). id_info->AddComments(comment_buffer); @@ -312,7 +312,7 @@ void Manager::Identifier(zeek::detail::IDPtr id) return; } - DbgAndWarn(zeek::util::fmt("Duplicate identifier documentation: %s", id->Name())); + DbgAndWarn(util::fmt("Duplicate identifier documentation: %s", id->Name())); return; } @@ -320,7 +320,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(zeek::DBG_ZEEKYGEN, "Made internal IdentifierInfo %s", + DBG_LOG(DBG_ZEEKYGEN, "Made internal IdentifierInfo %s", id->Name()); CreateIdentifierInfo(id, nullptr); return; @@ -335,12 +335,12 @@ void Manager::Identifier(zeek::detail::IDPtr id) return; } - DBG_LOG(zeek::DBG_ZEEKYGEN, "Making IdentifierInfo %s, in script %s", + DBG_LOG(DBG_ZEEKYGEN, "Making IdentifierInfo %s, in script %s", id->Name(), script.c_str()); CreateIdentifierInfo(std::move(id), script_info); } -void Manager::RecordField(const zeek::detail::ID* id, const zeek::TypeDecl* field, +void Manager::RecordField(const zeek::detail::ID* id, const TypeDecl* field, const string& path) { if ( disabled ) @@ -350,7 +350,7 @@ void Manager::RecordField(const zeek::detail::ID* id, const zeek::TypeDecl* fiel if ( ! idd ) { - DbgAndWarn(zeek::util::fmt("Can't generate zeekygen doumentation for " + DbgAndWarn(util::fmt("Can't generate zeekygen doumentation for " "record field %s, unknown record: %s", field->id, id->Name())); return; @@ -359,7 +359,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(zeek::DBG_ZEEKYGEN, "Document record field %s, identifier %s, script %s", + DBG_LOG(DBG_ZEEKYGEN, "Document record field %s, identifier %s, script %s", field->id, id->Name(), script.c_str()); } @@ -378,9 +378,9 @@ void Manager::Redef(const zeek::detail::ID* id, const string& path, if ( ! id_info ) { - DbgAndWarn(zeek::util::fmt("Can't generate zeekygen doumentation for " - "redef of %s, identifier lookup failed", - id->Name())); + DbgAndWarn(util::fmt("Can't generate zeekygen doumentation for " + "redef of %s, identifier lookup failed", + id->Name())); return; } @@ -397,7 +397,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(zeek::DBG_ZEEKYGEN, "Added redef of %s from %s", + DBG_LOG(DBG_ZEEKYGEN, "Added redef of %s from %s", id->Name(), from_script.c_str()); } @@ -418,8 +418,8 @@ void Manager::SummaryComment(const string& script, const string& comment) if ( info ) info->AddComment(RemoveLeadingSpace(comment)); else - DbgAndWarn(zeek::util::fmt("Lookup of script %s failed for summary comment %s", - name.c_str(), comment.c_str())); + DbgAndWarn(util::fmt("Lookup of script %s failed for summary comment %s", + name.c_str(), comment.c_str())); } void Manager::PreComment(const string& comment) @@ -440,8 +440,8 @@ void Manager::PostComment(const string& comment, const string& id_hint) if ( last_identifier_seen ) last_identifier_seen->AddComment(RemoveLeadingSpace(comment)); else - DbgAndWarn(zeek::util::fmt("Discarded unassociated Zeekygen comment %s", - comment.c_str())); + DbgAndWarn(util::fmt("Discarded unassociated Zeekygen comment %s", + comment.c_str())); return; } diff --git a/src/zeekygen/Manager.h b/src/zeekygen/Manager.h index 3be276c318..7bdd0205d1 100644 --- a/src/zeekygen/Manager.h +++ b/src/zeekygen/Manager.h @@ -127,7 +127,7 @@ public: * declared. This can be different from the place where the record type * is declared due to redefs. */ - void RecordField(const zeek::detail::ID* id, const zeek::TypeDecl* field, + void RecordField(const zeek::detail::ID* id, const TypeDecl* field, const std::string& path); /** @@ -244,8 +244,8 @@ bool Manager::IsUpToDate(const std::string& target_file, // Doesn't exist. return false; - zeek::reporter->InternalError("Zeekygen failed to stat target file '%s': %s", - target_file.c_str(), strerror(errno)); + reporter->InternalError("Zeekygen failed to stat target file '%s': %s", + target_file.c_str(), strerror(errno)); } if ( difftime(bro_mtime, s.st_mtime) > 0 ) @@ -265,7 +265,7 @@ bool Manager::IsUpToDate(const std::string& target_file, namespace zeek::detail { -extern zeek::zeekygen::detail::Manager* zeekygen_mgr; +extern zeekygen::detail::Manager* zeekygen_mgr; } // namespace zeek::detail diff --git a/src/zeekygen/PackageInfo.cc b/src/zeekygen/PackageInfo.cc index 6fd43fb99b..32c907b2ab 100644 --- a/src/zeekygen/PackageInfo.cc +++ b/src/zeekygen/PackageInfo.cc @@ -16,7 +16,7 @@ PackageInfo::PackageInfo(const string& arg_name) : Info(), pkg_name(arg_name), readme() { - string readme_file = zeek::util::find_file(pkg_name + "/README", zeek::util::zeek_path()); + string readme_file = util::find_file(pkg_name + "/README", util::zeek_path()); if ( readme_file.empty() ) return; @@ -24,8 +24,8 @@ PackageInfo::PackageInfo(const string& arg_name) ifstream f(readme_file.c_str()); if ( ! f.is_open() ) - zeek::reporter->InternalWarning("Zeekygen failed to open '%s': %s", - readme_file.c_str(), strerror(errno)); + reporter->InternalWarning("Zeekygen failed to open '%s': %s", + readme_file.c_str(), strerror(errno)); string line; @@ -33,14 +33,14 @@ PackageInfo::PackageInfo(const string& arg_name) readme.push_back(line); if ( f.bad() ) - zeek::reporter->InternalWarning("Zeekygen error reading '%s': %s", - readme_file.c_str(), strerror(errno)); + reporter->InternalWarning("Zeekygen error reading '%s': %s", + readme_file.c_str(), strerror(errno)); } string PackageInfo::DoReStructuredText(bool roles_only) const { - string rval = zeek::util::fmt(":doc:`%s `\n\n", pkg_name.c_str(), - pkg_name.c_str()); + string rval = util::fmt(":doc:`%s `\n\n", pkg_name.c_str(), + pkg_name.c_str()); for ( size_t i = 0; i < readme.size(); ++i ) rval += " " + readme[i] + "\n"; @@ -50,7 +50,7 @@ string PackageInfo::DoReStructuredText(bool roles_only) const time_t PackageInfo::DoGetModificationTime() const { - string readme_file = zeek::util::find_file(pkg_name + "/README", zeek::util::zeek_path()); + string readme_file = util::find_file(pkg_name + "/README", util::zeek_path()); if ( readme_file.empty() ) return 0; diff --git a/src/zeekygen/ScriptInfo.cc b/src/zeekygen/ScriptInfo.cc index c4a53b5582..06221734db 100644 --- a/src/zeekygen/ScriptInfo.cc +++ b/src/zeekygen/ScriptInfo.cc @@ -47,7 +47,7 @@ static vector summary_comment(const vector& cmnts) return rval; } -static void add_summary_rows(const zeek::ODesc& id_desc, const vector& cmnts, +static void add_summary_rows(const ODesc& id_desc, const vector& cmnts, ReStructuredTextTable* table) { vector row; @@ -84,7 +84,7 @@ static string make_summary(const string& heading, char underline, char border, it != id_list.end(); ++it ) { auto* id = (*it)->GetID(); - zeek::ODesc d; + ODesc d; d.SetQuotes(true); id->DescribeReSTShort(&d); add_summary_rows(d, summary_comment((*it)->GetComments()), &table); @@ -107,7 +107,7 @@ static string make_redef_summary(const string& heading, char underline, ++it ) { auto* id = (*it)->GetID(); - zeek::ODesc d; + ODesc d; d.SetQuotes(true); id->DescribeReSTShort(&d); @@ -162,7 +162,7 @@ static string make_redef_details(const string& heading, char underline, ScriptInfo::ScriptInfo(const string& arg_name, const string& arg_path) : Info(), name(arg_name), path(arg_path), - is_pkg_loader(zeek::util::detail::is_package_loader(name)), + is_pkg_loader(util::detail::is_package_loader(name)), dependencies(), module_usages(), comments(), id_info(), redef_options(), constants(), state_vars(), types(), events(), hooks(), functions(), redefs() @@ -188,31 +188,31 @@ void ScriptInfo::DoInitPostScript() if ( id->IsType() ) { types.push_back(info); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a type", + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a type", id->Name(), name.c_str()); continue; } - if ( zeek::IsFunc(id->GetType()->Tag()) ) + if ( IsFunc(id->GetType()->Tag()) ) { switch ( id->GetType()->AsFuncType()->Flavor() ) { - case zeek::FUNC_FLAVOR_HOOK: - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a hook", + case FUNC_FLAVOR_HOOK: + DBG_LOG(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(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a event", + case FUNC_FLAVOR_EVENT: + DBG_LOG(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(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a function", + case FUNC_FLAVOR_FUNCTION: + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a function", id->Name(), name.c_str()); functions.push_back(info); break; default: - zeek::reporter->InternalError("Invalid function flavor"); + reporter->InternalError("Invalid function flavor"); break; } @@ -223,13 +223,13 @@ void ScriptInfo::DoInitPostScript() { if ( id->GetAttr(zeek::detail::ATTR_REDEF) ) { - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a redef_option", + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a redef_option", id->Name(), name.c_str()); redef_options.push_back(info); } else { - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a constant", + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a constant", id->Name(), name.c_str()); constants.push_back(info); } @@ -238,19 +238,19 @@ void ScriptInfo::DoInitPostScript() } else if ( id->IsOption() ) { - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as an runtime option", + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as an runtime option", id->Name(), name.c_str()); options.push_back(info); continue; } - if ( id->GetType()->Tag() == zeek::TYPE_ENUM ) + if ( id->GetType()->Tag() == TYPE_ENUM ) // Enums are always referenced/documented from the type's // documentation. continue; - DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a state variable", + DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a state variable", id->Name(), name.c_str()); state_vars.push_back(info); } @@ -318,20 +318,20 @@ string ScriptInfo::DoReStructuredText(bool roles_only) const if ( it != dependencies.begin() ) rval += ", "; - string path = zeek::util::find_script_file(*it, zeek::util::zeek_path()); + string path = util::find_script_file(*it, util::zeek_path()); string doc = *it; - if ( ! path.empty() && zeek::util::is_dir(path.c_str()) ) + if ( ! path.empty() && util::is_dir(path.c_str()) ) // Reference the package. doc += "/index"; - rval += zeek::util::fmt(":doc:`%s `", it->c_str(), doc.c_str()); + rval += util::fmt(":doc:`%s `", it->c_str(), doc.c_str()); } rval += "\n"; } - //rval += zeek::util::fmt(":Source File: :download:`/scripts/%s`\n", name.c_str()); + //rval += util::fmt(":Source File: :download:`/scripts/%s`\n", name.c_str()); rval += "\n"; rval += make_heading("Summary", '~'); rval += make_summary("Runtime Options", '#', '=', options); @@ -369,7 +369,7 @@ time_t ScriptInfo::DoGetModificationTime() const if ( ! info ) { - for (const string& ext : zeek::util::detail::script_extensions) + for (const string& ext : util::detail::script_extensions) { string pkg_name = *it + "/__load__" + ext; info = zeek::detail::zeekygen_mgr->GetScriptInfo(pkg_name); @@ -378,8 +378,8 @@ time_t ScriptInfo::DoGetModificationTime() const } if ( ! info ) - zeek::reporter->InternalWarning("Zeekygen failed to get mtime of %s", - it->c_str()); + reporter->InternalWarning("Zeekygen failed to get mtime of %s", + it->c_str()); continue; } diff --git a/src/zeekygen/Target.cc b/src/zeekygen/Target.cc index d2393dfa11..ee9aa818d5 100644 --- a/src/zeekygen/Target.cc +++ b/src/zeekygen/Target.cc @@ -22,7 +22,7 @@ using namespace std; namespace zeek::zeekygen::detail { -static void write_plugin_section_heading(FILE* f, const zeek::plugin::Plugin* p) +static void write_plugin_section_heading(FILE* f, const plugin::Plugin* p) { const string& name = p->Name(); @@ -34,31 +34,31 @@ static void write_plugin_section_heading(FILE* f, const zeek::plugin::Plugin* p) fprintf(f, "%s\n\n", p->Description().c_str()); } -static void write_analyzer_component(FILE* f, const zeek::analyzer::Component* c) +static void write_analyzer_component(FILE* f, const analyzer::Component* c) { - const auto& atag = zeek::analyzer_mgr->GetTagType(); - string tag = zeek::util::fmt("ANALYZER_%s", c->CanonicalName().c_str()); + const auto& atag = analyzer_mgr->GetTagType(); + string tag = util::fmt("ANALYZER_%s", c->CanonicalName().c_str()); if ( atag->Lookup("Analyzer", tag.c_str()) < 0 ) - zeek::reporter->InternalError("missing analyzer tag for %s", tag.c_str()); + reporter->InternalError("missing analyzer tag for %s", tag.c_str()); fprintf(f, ":zeek:enum:`Analyzer::%s`\n\n", tag.c_str()); } -static void write_analyzer_component(FILE* f, const zeek::file_analysis::Component* c) +static void write_analyzer_component(FILE* f, const file_analysis::Component* c) { - const auto& atag = zeek::file_mgr->GetTagType(); - string tag = zeek::util::fmt("ANALYZER_%s", c->CanonicalName().c_str()); + const auto& atag = file_mgr->GetTagType(); + string tag = util::fmt("ANALYZER_%s", c->CanonicalName().c_str()); if ( atag->Lookup("Files", tag.c_str()) < 0 ) - zeek::reporter->InternalError("missing analyzer tag for %s", tag.c_str()); + reporter->InternalError("missing analyzer tag for %s", tag.c_str()); fprintf(f, ":zeek:enum:`Files::%s`\n\n", tag.c_str()); } -static void write_plugin_components(FILE* f, const zeek::plugin::Plugin* p) +static void write_plugin_components(FILE* f, const plugin::Plugin* p) { - zeek::plugin::Plugin::component_list components = p->Components(); + plugin::Plugin::component_list components = p->Components(); fprintf(f, "Components\n"); fprintf(f, "++++++++++\n\n"); @@ -66,47 +66,47 @@ static void write_plugin_components(FILE* f, const zeek::plugin::Plugin* p) for ( const auto& component : components ) { switch ( component->Type() ) { - case zeek::plugin::component::ANALYZER: + case plugin::component::ANALYZER: { - const zeek::analyzer::Component* c = - dynamic_cast(component); + const analyzer::Component* c = + dynamic_cast(component); if ( c ) write_analyzer_component(f, c); else - zeek::reporter->InternalError("component type mismatch"); + reporter->InternalError("component type mismatch"); } break; - case zeek::plugin::component::FILE_ANALYZER: + case plugin::component::FILE_ANALYZER: { const auto* c = - dynamic_cast(component); + dynamic_cast(component); if ( c ) write_analyzer_component(f, c); else - zeek::reporter->InternalError("component type mismatch"); + reporter->InternalError("component type mismatch"); } break; - case zeek::plugin::component::READER: - zeek::reporter->InternalError("docs for READER component unimplemented"); + case plugin::component::READER: + reporter->InternalError("docs for READER component unimplemented"); - case zeek::plugin::component::WRITER: - zeek::reporter->InternalError("docs for WRITER component unimplemented"); + case plugin::component::WRITER: + reporter->InternalError("docs for WRITER component unimplemented"); default: - zeek::reporter->InternalError("docs for unknown component unimplemented"); + reporter->InternalError("docs for unknown component unimplemented"); } } } -static void write_plugin_bif_items(FILE* f, const zeek::plugin::Plugin* p, - zeek::plugin::BifItem::Type t, const string& heading) +static void write_plugin_bif_items(FILE* f, const plugin::Plugin* p, + plugin::BifItem::Type t, const string& heading) { - zeek::plugin::Plugin::bif_item_list bifitems = p->BifItems(); - zeek::plugin::Plugin::bif_item_list::iterator it = bifitems.begin(); + plugin::Plugin::bif_item_list bifitems = p->BifItems(); + plugin::Plugin::bif_item_list::iterator it = bifitems.begin(); while ( it != bifitems.end() ) { @@ -132,8 +132,8 @@ static void write_plugin_bif_items(FILE* f, const zeek::plugin::Plugin* p, if ( doc ) fprintf(f, "%s\n\n", doc->ReStructuredText().c_str()); else - zeek::reporter->InternalWarning("Zeekygen ID lookup failed: %s\n", - it->GetID().c_str()); + reporter->InternalWarning("Zeekygen ID lookup failed: %s\n", + it->GetID().c_str()); } } @@ -144,17 +144,17 @@ static void WriteAnalyzerTagDefn(FILE* f, const string& module) IdentifierInfo* doc = zeek::detail::zeekygen_mgr->GetIdentifierInfo(tag_id); if ( ! doc ) - zeek::reporter->InternalError("Zeekygen failed analyzer tag lookup: %s", - tag_id.c_str()); + reporter->InternalError("Zeekygen failed analyzer tag lookup: %s", + tag_id.c_str()); fprintf(f, "%s\n", doc->ReStructuredText().c_str()); } -static bool ComponentsMatch(const zeek::plugin::Plugin* p, zeek::plugin::component::Type t, +static bool ComponentsMatch(const plugin::Plugin* p, plugin::component::Type t, bool match_empty = false) { - zeek::plugin::Plugin::component_list components = p->Components(); - zeek::plugin::Plugin::component_list::const_iterator it; + plugin::Plugin::component_list components = p->Components(); + plugin::Plugin::component_list::const_iterator it; if ( components.empty() ) return match_empty; @@ -180,7 +180,7 @@ static vector filter_matches(const vector& from, Target* t) if ( t->MatchesPattern(d) ) { - DBG_LOG(zeek::DBG_ZEEKYGEN, "'%s' matched pattern for target '%s'", + DBG_LOG(DBG_ZEEKYGEN, "'%s' matched pattern for target '%s'", d->Name().c_str(), t->Name().c_str()); rval.push_back(d); } @@ -194,18 +194,18 @@ TargetFile::TargetFile(const string& arg_name) { if ( name.find('/') != string::npos ) { - string dir = zeek::util::SafeDirname(name).result; + string dir = util::SafeDirname(name).result; - if ( ! zeek::util::detail::ensure_intermediate_dirs(dir.c_str()) ) - zeek::reporter->FatalError("Zeekygen failed to make dir %s", - dir.c_str()); + if ( ! util::detail::ensure_intermediate_dirs(dir.c_str()) ) + reporter->FatalError("Zeekygen failed to make dir %s", + dir.c_str()); } f = fopen(name.c_str(), "w"); if ( ! f ) - zeek::reporter->FatalError("Zeekygen failed to open '%s' for writing: %s", - name.c_str(), strerror(errno)); + reporter->FatalError("Zeekygen failed to open '%s' for writing: %s", + name.c_str(), strerror(errno)); } TargetFile::~TargetFile() @@ -213,7 +213,7 @@ TargetFile::~TargetFile() if ( f ) fclose(f); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Wrote out-of-date target '%s'", name.c_str()); + DBG_LOG(DBG_ZEEKYGEN, "Wrote out-of-date target '%s'", name.c_str()); } @@ -252,8 +252,8 @@ void AnalyzerTarget::DoGenerate() const return; if ( Pattern() != "*" ) - zeek::reporter->InternalWarning("Zeekygen only implements analyzer target" - " pattern '*'"); + reporter->InternalWarning("Zeekygen only implements analyzer target" + " pattern '*'"); TargetFile file(Name()); CreateAnalyzerDoc(file.f); @@ -266,22 +266,22 @@ void ProtoAnalyzerTarget::DoCreateAnalyzerDoc(FILE* f) const WriteAnalyzerTagDefn(f, "Analyzer"); - zeek::plugin::Manager::plugin_list plugins = zeek::plugin_mgr->ActivePlugins(); - zeek::plugin::Manager::plugin_list::const_iterator it; + plugin::Manager::plugin_list plugins = plugin_mgr->ActivePlugins(); + plugin::Manager::plugin_list::const_iterator it; for ( it = plugins.begin(); it != plugins.end(); ++it ) { - if ( ! ComponentsMatch(*it, zeek::plugin::component::ANALYZER, true) ) + if ( ! ComponentsMatch(*it, plugin::component::ANALYZER, true) ) continue; write_plugin_section_heading(f, *it); write_plugin_components(f, *it); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::CONSTANT, + write_plugin_bif_items(f, *it, plugin::BifItem::CONSTANT, "Options/Constants"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::GLOBAL, "Globals"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::TYPE, "Types"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::EVENT, "Events"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::FUNCTION, "Functions"); + write_plugin_bif_items(f, *it, plugin::BifItem::GLOBAL, "Globals"); + write_plugin_bif_items(f, *it, plugin::BifItem::TYPE, "Types"); + write_plugin_bif_items(f, *it, plugin::BifItem::EVENT, "Events"); + write_plugin_bif_items(f, *it, plugin::BifItem::FUNCTION, "Functions"); } } @@ -292,22 +292,22 @@ void FileAnalyzerTarget::DoCreateAnalyzerDoc(FILE* f) const WriteAnalyzerTagDefn(f, "Files"); - zeek::plugin::Manager::plugin_list plugins = zeek::plugin_mgr->ActivePlugins(); - zeek::plugin::Manager::plugin_list::const_iterator it; + plugin::Manager::plugin_list plugins = plugin_mgr->ActivePlugins(); + plugin::Manager::plugin_list::const_iterator it; for ( it = plugins.begin(); it != plugins.end(); ++it ) { - if ( ! ComponentsMatch(*it, zeek::plugin::component::FILE_ANALYZER) ) + if ( ! ComponentsMatch(*it, plugin::component::FILE_ANALYZER) ) continue; write_plugin_section_heading(f, *it); write_plugin_components(f, *it); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::CONSTANT, + write_plugin_bif_items(f, *it, plugin::BifItem::CONSTANT, "Options/Constants"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::GLOBAL, "Globals"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::TYPE, "Types"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::EVENT, "Events"); - write_plugin_bif_items(f, *it, zeek::plugin::BifItem::FUNCTION, "Functions"); + write_plugin_bif_items(f, *it, plugin::BifItem::GLOBAL, "Globals"); + write_plugin_bif_items(f, *it, plugin::BifItem::TYPE, "Types"); + write_plugin_bif_items(f, *it, plugin::BifItem::EVENT, "Events"); + write_plugin_bif_items(f, *it, plugin::BifItem::FUNCTION, "Functions"); } } @@ -316,8 +316,8 @@ void PackageTarget::DoFindDependencies(const vector& infos) pkg_deps = filter_matches(infos, this); if ( pkg_deps.empty() ) - zeek::reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", - Name().c_str(), Pattern().c_str()); + reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", + Name().c_str(), Pattern().c_str()); for ( size_t i = 0; i < infos.size(); ++i ) { @@ -332,7 +332,7 @@ void PackageTarget::DoFindDependencies(const vector& infos) pkg_deps[j]->Name().size())) continue; - DBG_LOG(zeek::DBG_ZEEKYGEN, "Script %s associated with package %s", + DBG_LOG(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); @@ -353,7 +353,7 @@ void PackageTarget::DoGenerate() const for ( manifest_t::const_iterator it = pkg_manifest.begin(); it != pkg_manifest.end(); ++it ) { - string header = zeek::util::fmt("Package: %s", it->first->Name().c_str()); + string header = util::fmt("Package: %s", it->first->Name().c_str()); header += "\n" + string(header.size(), '='); fprintf(file.f, "%s\n\n", header.c_str()); @@ -385,8 +385,8 @@ void PackageIndexTarget::DoFindDependencies(const vector& infos) pkg_deps = filter_matches(infos, this); if ( pkg_deps.empty() ) - zeek::reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", - Name().c_str(), Pattern().c_str()); + reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", + Name().c_str(), Pattern().c_str()); } void PackageIndexTarget::DoGenerate() const @@ -405,17 +405,17 @@ void ScriptTarget::DoFindDependencies(const vector& infos) script_deps = filter_matches(infos, this); if ( script_deps.empty() ) - zeek::reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", - Name().c_str(), Pattern().c_str()); + reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", + Name().c_str(), Pattern().c_str()); if ( ! IsDir() ) return; for ( size_t i = 0; i < script_deps.size(); ++i ) { - if ( zeek::util::detail::is_package_loader(script_deps[i]->Name()) ) + if ( util::detail::is_package_loader(script_deps[i]->Name()) ) { - string pkg_dir = zeek::util::SafeDirname(script_deps[i]->Name()).result; + string pkg_dir = util::SafeDirname(script_deps[i]->Name()).result; string target_file = Name() + pkg_dir + "/index.rst"; Target* t = new PackageTarget(target_file, pkg_dir); t->FindDependencies(infos); @@ -435,7 +435,7 @@ vector dir_contents_recursive(string dir) while ( dir[dir.size() - 1] == '/' ) dir.erase(dir.size() - 1, 1); - char* dir_copy = zeek::util::copy_string(dir.c_str()); + char* dir_copy = util::copy_string(dir.c_str()); char** scan_path = new char*[2]; scan_path[0] = dir_copy; scan_path[1] = NULL; @@ -444,7 +444,7 @@ vector dir_contents_recursive(string dir) if ( ! fts ) { - zeek::reporter->Error("fts_open failure: %s", strerror(errno)); + reporter->Error("fts_open failure: %s", strerror(errno)); delete [] scan_path; delete [] dir_copy; return rval; @@ -459,10 +459,10 @@ vector dir_contents_recursive(string dir) } if ( errno ) - zeek::reporter->Error("fts_read failure: %s", strerror(errno)); + reporter->Error("fts_read failure: %s", strerror(errno)); if ( fts_close(fts) < 0 ) - zeek::reporter->Error("fts_close failure: %s", strerror(errno)); + reporter->Error("fts_close failure: %s", strerror(errno)); delete [] scan_path; delete [] dir_copy; @@ -508,10 +508,10 @@ void ScriptTarget::DoGenerate() const continue; if ( unlink(f.c_str()) < 0 ) - zeek::reporter->Warning("Failed to unlink %s: %s", f.c_str(), - strerror(errno)); + reporter->Warning("Failed to unlink %s: %s", f.c_str(), + strerror(errno)); - DBG_LOG(zeek::DBG_ZEEKYGEN, "Delete stale script file %s", f.c_str()); + DBG_LOG(DBG_ZEEKYGEN, "Delete stale script file %s", f.c_str()); } return; @@ -580,7 +580,7 @@ void IdentifierTarget::DoFindDependencies(const vector& infos) id_deps = filter_matches(infos, this); if ( id_deps.empty() ) - zeek::reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", + reporter->FatalError("No match for Zeekygen target '%s' pattern '%s'", Name().c_str(), Pattern().c_str()); } diff --git a/src/zeekygen/utils.cc b/src/zeekygen/utils.cc index 9e950d7d4e..d4410f76ad 100644 --- a/src/zeekygen/utils.cc +++ b/src/zeekygen/utils.cc @@ -90,8 +90,8 @@ time_t get_mtime(const string& filename) struct stat s; if ( stat(filename.c_str(), &s) < 0 ) - zeek::reporter->InternalError("Zeekygen failed to stat file '%s': %s", - filename.c_str(), strerror(errno)); + reporter->InternalError("Zeekygen failed to stat file '%s': %s", + filename.c_str(), strerror(errno)); return s.st_mtime; } @@ -133,8 +133,8 @@ bool is_all_whitespace(const string& s) string redef_indication(const string& from_script) { - return zeek::util::fmt("(present if :doc:`/scripts/%s` is loaded)", - from_script.c_str()); + return util::fmt("(present if :doc:`/scripts/%s` is loaded)", + from_script.c_str()); } } // namespace zeek::zeekygen::detail