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

Use type aliases for IntrusivePtr definitions

Browse source
This commit is contained in:
Tim Wojtulewicz 2020-06-24 16:46:34 -04:00
parent f6a251cdac
commit ec9eff0bd5
180 changed files with 2026 additions and 1893 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/Anon.cc
View file

@ -358,9 +358,9 @@ AnonymizeIPAddr_A50::Node* AnonymizeIPAddr_A50::find_node(ipaddr32_t a)
return nullptr;
}
static zeek::IntrusivePtr<TableVal> anon_preserve_orig_addr;
static zeek::IntrusivePtr<TableVal> anon_preserve_resp_addr;
static zeek::IntrusivePtr<TableVal> 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()
{

22
src/Attr.cc
View file

@ -25,7 +25,7 @@ const char* attr_name(AttrTag t)
return attr_names[int(t)];
}
Attr::Attr(AttrTag t, zeek::IntrusivePtr<Expr> e)
Attr::Attr(AttrTag t, ExprPtr e)
: expr(std::move(e))
{
tag = t;
@ -37,7 +37,7 @@ Attr::Attr(AttrTag t)
{
}
void Attr::SetAttrExpr(zeek::IntrusivePtr<zeek::detail::Expr> e)
void Attr::SetAttrExpr(ExprPtr e)
{ expr = std::move(e); }
void Attr::Describe(ODesc* d) const
@ -136,7 +136,7 @@ void Attr::AddTag(ODesc* d) const
d->Add(attr_name(Tag()));
}
Attributes::Attributes(attr_list* a, zeek::IntrusivePtr<Type> t, bool arg_in_record, bool is_global)
Attributes::Attributes(attr_list* a, TypePtr t, bool arg_in_record, bool is_global)
{
attrs_list.resize(a->length());
attrs.reserve(a->length());
@ -155,15 +155,13 @@ Attributes::Attributes(attr_list* a, zeek::IntrusivePtr<Type> t, bool arg_in_rec
delete a;
}
Attributes::Attributes(zeek::IntrusivePtr<Type> t,
bool arg_in_record, bool is_global)
: Attributes(std::vector<zeek::IntrusivePtr<Attr>>{}, std::move(t),
Attributes::Attributes(TypePtr t, bool arg_in_record, bool is_global)
: Attributes(std::vector<AttrPtr>{}, std::move(t),
arg_in_record, is_global)
{}
Attributes::Attributes(std::vector<zeek::IntrusivePtr<Attr>> a,
zeek::IntrusivePtr<Type> t,
bool arg_in_record, bool is_global)
Attributes::Attributes(std::vector<AttrPtr> a,
TypePtr t, bool arg_in_record, bool is_global)
: type(std::move(t))
{
attrs_list.resize(a.size());
@ -181,7 +179,7 @@ Attributes::Attributes(std::vector<zeek::IntrusivePtr<Attr>> a,
AddAttr(std::move(attr));
}
void Attributes::AddAttr(zeek::IntrusivePtr<Attr> attr)
void Attributes::AddAttr(AttrPtr attr)
{
// We overwrite old attributes by deleting them first.
RemoveAttr(attr->Tag());
@ -212,7 +210,7 @@ void Attributes::AddAttr(zeek::IntrusivePtr<Attr> attr)
}
}
void Attributes::AddAttrs(const zeek::IntrusivePtr<Attributes>& a)
void Attributes::AddAttrs(const AttributesPtr& a)
{
for ( const auto& attr : a->GetAttrs() )
AddAttr(attr);
@ -235,7 +233,7 @@ Attr* Attributes::FindAttr(AttrTag t) const
return nullptr;
}
const zeek::IntrusivePtr<Attr>& Attributes::Find(AttrTag t) const
const AttrPtr& Attributes::Find(AttrTag t) const
{
for ( const auto& a : attrs )
if ( a->Tag() == t )

42
src/Attr.h
View file

@ -10,6 +10,15 @@
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
namespace zeek {
class Type;
using TypePtr = IntrusivePtr<Type>;
namespace detail {
using ExprPtr = zeek::IntrusivePtr<Expr>;
}
}
// Note that there are two kinds of attributes: the kind (here) which
// modify expressions or supply metadata on types, and the kind that
// are extra metadata on every variable instance.
@ -38,11 +47,16 @@ enum AttrTag {
NUM_ATTRS // this item should always be last
};
class Attr;
using AttrPtr = zeek::IntrusivePtr<Attr>;
class Attributes;
using AttributesPtr = zeek::IntrusivePtr<Attributes>;
class Attr final : public BroObj {
public:
static inline const zeek::IntrusivePtr<zeek::detail::Attr> nil;
static inline const AttrPtr nil;
Attr(AttrTag t, zeek::IntrusivePtr<zeek::detail::Expr> e);
Attr(AttrTag t, ExprPtr e);
explicit Attr(AttrTag t);
~Attr() override = default;
@ -52,10 +66,10 @@ public:
[[deprecated("Remove in v4.1. Use GetExpr().")]]
zeek::detail::Expr* AttrExpr() const { return expr.get(); }
const zeek::IntrusivePtr<zeek::detail::Expr>& GetExpr() const
const ExprPtr& GetExpr() const
{ return expr; }
void SetAttrExpr(zeek::IntrusivePtr<zeek::detail::Expr> e);
void SetAttrExpr(ExprPtr e);
void Describe(ODesc* d) const override;
void DescribeReST(ODesc* d, bool shorten = false) const;
@ -78,24 +92,24 @@ protected:
void AddTag(ODesc* d) const;
AttrTag tag;
zeek::IntrusivePtr<Expr> expr;
ExprPtr expr;
};
// Manages a collection of attributes.
class Attributes final : public BroObj {
public:
[[deprecated("Remove in v4.1. Construct using IntrusivePtrs instead.")]]
Attributes(attr_list* a, zeek::IntrusivePtr<Type> t, bool in_record, bool is_global);
Attributes(attr_list* a, zeek::TypePtr t, bool in_record, bool is_global);
Attributes(std::vector<zeek::IntrusivePtr<Attr>> a, zeek::IntrusivePtr<Type> t,
Attributes(std::vector<AttrPtr> a, zeek::TypePtr t,
bool in_record, bool is_global);
Attributes(zeek::IntrusivePtr<Type> t, bool in_record, bool is_global);
Attributes(TypePtr t, bool in_record, bool is_global);
~Attributes() override = default;
void AddAttr(zeek::IntrusivePtr<Attr> a);
void AddAttr(AttrPtr a);
void AddAttrs(const zeek::IntrusivePtr<Attributes>& a);
void AddAttrs(const AttributesPtr& a);
[[deprecated("Remove in v4.1. Pass IntrusivePtr instead.")]]
void AddAttrs(Attributes* a); // Unref's 'a' when done
@ -103,7 +117,7 @@ public:
[[deprecated("Remove in v4.1. Use Find().")]]
Attr* FindAttr(AttrTag t) const;
const zeek::IntrusivePtr<Attr>& Find(AttrTag t) const;
const AttrPtr& Find(AttrTag t) const;
void RemoveAttr(AttrTag t);
@ -114,7 +128,7 @@ public:
const attr_list* Attrs() const
{ return &attrs_list; }
const std::vector<zeek::IntrusivePtr<Attr>>& GetAttrs() const
const std::vector<AttrPtr>& GetAttrs() const
{ return attrs; }
bool operator==(const Attributes& other) const;
@ -122,8 +136,8 @@ public:
protected:
void CheckAttr(Attr* attr);
zeek::IntrusivePtr<Type> type;
std::vector<zeek::IntrusivePtr<Attr>> attrs;
TypePtr type;
std::vector<AttrPtr> attrs;
// Remove in v4.1. This is used by Attrs(), which is deprecated.
attr_list attrs_list;

3
src/BifReturnVal.h
View file

@ -5,6 +5,7 @@
#include "IntrusivePtr.h"
class Val;
using ValPtr = zeek::IntrusivePtr<Val>;
/**
* A simple wrapper class to use for the return value of BIFs so that
@ -24,5 +25,5 @@ public:
[[deprecated("Remove in v4.1. Return an IntrusivePtr instead.")]]
BifReturnVal(Val* v) noexcept;
zeek::IntrusivePtr<Val> rval;
ValPtr rval;
};

20
src/CompHash.cc
View file

@ -15,7 +15,7 @@
#include "Func.h"
#include "IPAddr.h"
CompositeHash::CompositeHash(zeek::IntrusivePtr<zeek::TypeList> composite_type)
CompositeHash::CompositeHash(zeek::TypeListPtr composite_type)
: type(std::move(composite_type))
{
singleton_tag = zeek::TYPE_INTERNAL_ERROR;
@ -709,7 +709,7 @@ int CompositeHash::SizeAlign(int offset, unsigned int size) const
return offset;
}
zeek::IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey& k) const
ListValPtr CompositeHash::RecoverVals(const HashKey& k) const
{
auto l = zeek::make_intrusive<ListVal>(zeek::TYPE_ANY);
const auto& tl = type->GetTypes();
@ -718,7 +718,7 @@ zeek::IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey& k) const
for ( const auto& type : tl )
{
zeek::IntrusivePtr<Val> v;
ValPtr v;
kp = RecoverOneVal(k, kp, k_end, type.get(), &v, false);
ASSERT(v);
l->Append(std::move(v));
@ -733,7 +733,7 @@ zeek::IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey& k) const
const char* CompositeHash::RecoverOneVal(
const HashKey& k, const char* kp0,
const char* const k_end, zeek::Type* t,
zeek::IntrusivePtr<Val>* pval, bool optional) const
ValPtr* pval, bool optional) const
{
// k->Size() == 0 for a single empty string.
if ( kp0 >= k_end && k.Size() > 0 )
@ -904,11 +904,11 @@ const char* CompositeHash::RecoverOneVal(
zeek::RecordType* rt = t->AsRecordType();
int num_fields = rt->NumFields();
std::vector<zeek::IntrusivePtr<Val>> values;
std::vector<ValPtr> values;
int i;
for ( i = 0; i < num_fields; ++i )
{
zeek::IntrusivePtr<Val> v;
ValPtr v;
zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL));
@ -952,14 +952,14 @@ const char* CompositeHash::RecoverOneVal(
for ( int i = 0; i < n; ++i )
{
zeek::IntrusivePtr<Val> 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::IntrusivePtr<Val> value;
ValPtr value;
kp1 = RecoverOneVal(k, kp1, k_end, tt->Yield().get(), &value,
false);
tv->Assign(std::move(key), std::move(value));
@ -987,7 +987,7 @@ const char* CompositeHash::RecoverOneVal(
kp = AlignType<unsigned int>(kp1);
unsigned int have_val = *kp;
kp1 = reinterpret_cast<const char*>(kp+1);
zeek::IntrusivePtr<Val> value;
ValPtr value;
if ( have_val )
kp1 = RecoverOneVal(k, kp1, k_end, vt->Yield().get(), &value,
@ -1011,7 +1011,7 @@ const char* CompositeHash::RecoverOneVal(
for ( int i = 0; i < n; ++i )
{
zeek::IntrusivePtr<Val> v;
ValPtr v;
zeek::Type* it = tl->GetTypes()[i].get();
kp1 = RecoverOneVal(k, kp1, k_end, it, &v, false);
lv->Append(std::move(v));

12
src/CompHash.h
View file

@ -10,9 +10,11 @@
class ListVal;
class HashKey;
using ListValPtr = zeek::IntrusivePtr<ListVal>;
class CompositeHash {
public:
explicit CompositeHash(zeek::IntrusivePtr<zeek::TypeList> composite_type);
explicit CompositeHash(zeek::TypeListPtr composite_type);
~CompositeHash();
// Compute the hash corresponding to the given index val,
@ -24,10 +26,10 @@ public:
{ return MakeHashKey(*v, type_check).release(); }
// Given a hash key, recover the values used to create it.
zeek::IntrusivePtr<ListVal> RecoverVals(const HashKey& k) const;
ListValPtr RecoverVals(const HashKey& k) const;
[[deprecated("Remove in v4.1. Pass in HashKey& instead.")]]
zeek::IntrusivePtr<ListVal> RecoverVals(const HashKey* k) const
ListValPtr RecoverVals(const HashKey* k) const
{ return RecoverVals(*k); }
unsigned int MemoryAllocation() const { return padded_sizeof(*this) + pad_size(size); }
@ -46,7 +48,7 @@ protected:
// upon errors, so there is no return value for invalid input.
const char* RecoverOneVal(
const HashKey& k, const char* kp, const char* const k_end,
zeek::Type* t, zeek::IntrusivePtr<Val>* pval, bool optional) const;
zeek::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.
@ -89,7 +91,7 @@ protected:
bool type_check, int sz, bool optional,
bool calc_static_size) const;
zeek::IntrusivePtr<zeek::TypeList> type;
zeek::TypeListPtr type;
char* key; // space for composite key
int size;
bool is_singleton; // if just one type in index

2
src/Conn.cc
View file

@ -342,7 +342,7 @@ RecordVal* Connection::BuildConnVal()
return ConnVal()->Ref()->AsRecordVal();
}
const zeek::IntrusivePtr<RecordVal>& Connection::ConnVal()
const RecordValPtr& Connection::ConnVal()
{
if ( ! conn_val )
{

9
src/Conn.h
View file

@ -32,6 +32,9 @@ class EncapsulationStack;
class Val;
class RecordVal;
using ValPtr = zeek::IntrusivePtr<Val>;
using RecordValPtr = zeek::IntrusivePtr<RecordVal>;
namespace analyzer { class TransportLayerAnalyzer; }
typedef enum {
@ -169,7 +172,7 @@ public:
/**
* Returns the associated "connection" record.
*/
const zeek::IntrusivePtr<RecordVal>& ConnVal();
const RecordValPtr& ConnVal();
void AppendAddl(const char* str);
@ -235,7 +238,7 @@ public:
template <class... Args>
std::enable_if_t<
std::is_convertible_v<
std::tuple_element_t<0, std::tuple<Args...>>, zeek::IntrusivePtr<Val>>>
std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>>
EnqueueEvent(EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args)
{ return EnqueueEvent(h, analyzer, zeek::Args{std::forward<Args>(args)...}); }
@ -355,7 +358,7 @@ protected:
u_char resp_l2_addr[Packet::l2_addr_len]; // Link-layer responder address, if available
double start_time, last_time;
double inactivity_timeout;
zeek::IntrusivePtr<RecordVal> conn_val;
RecordValPtr conn_val;
LoginConn* login_conn; // either nil, or this
const EncapsulationStack* encapsulation; // tunnels
int suppress_event; // suppress certain events to once per conn.

34
src/DNS_Mgr.cc
View file

@ -122,9 +122,9 @@ public:
return req_host ? req_host : req_addr.AsString();
}
zeek::IntrusivePtr<ListVal> Addrs();
zeek::IntrusivePtr<TableVal> AddrsSet(); // addresses returned as a set
zeek::IntrusivePtr<StringVal> Host();
ListValPtr Addrs();
TableValPtr AddrsSet(); // addresses returned as a set
StringValPtr Host();
double CreationTime() const { return creation_time; }
@ -155,11 +155,11 @@ protected:
int num_names;
char** names;
zeek::IntrusivePtr<StringVal> host_val;
StringValPtr host_val;
int num_addrs;
IPAddr* addrs;
zeek::IntrusivePtr<ListVal> addrs_val;
ListValPtr addrs_val;
double creation_time;
int map_type;
@ -173,7 +173,7 @@ void DNS_Mgr_mapping_delete_func(void* v)
delete (DNS_Mapping*) v;
}
static zeek::IntrusivePtr<TableVal> empty_addr_set()
static TableValPtr empty_addr_set()
{
auto addr_t = zeek::base_type(zeek::TYPE_ADDR);
auto set_index = zeek::make_intrusive<zeek::TypeList>(addr_t);
@ -276,7 +276,7 @@ DNS_Mapping::~DNS_Mapping()
delete [] addrs;
}
zeek::IntrusivePtr<ListVal> DNS_Mapping::Addrs()
ListValPtr DNS_Mapping::Addrs()
{
if ( failed )
return nullptr;
@ -292,7 +292,7 @@ zeek::IntrusivePtr<ListVal> DNS_Mapping::Addrs()
return addrs_val;
}
zeek::IntrusivePtr<TableVal> DNS_Mapping::AddrsSet() {
TableValPtr DNS_Mapping::AddrsSet() {
auto l = Addrs();
if ( ! l )
@ -301,7 +301,7 @@ zeek::IntrusivePtr<TableVal> DNS_Mapping::AddrsSet() {
return l->ToSetVal();
}
zeek::IntrusivePtr<StringVal> DNS_Mapping::Host()
StringValPtr DNS_Mapping::Host()
{
if ( failed || num_names == 0 || ! names[0] )
return nullptr;
@ -461,7 +461,7 @@ void DNS_Mgr::InitPostScript()
LoadCache(fopen(cache_name, "r"));
}
static zeek::IntrusivePtr<TableVal> 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);
@ -485,7 +485,7 @@ static const char* fake_addr_lookup_result(const IPAddr& addr)
return tmp;
}
zeek::IntrusivePtr<TableVal> DNS_Mgr::LookupHost(const char* name)
TableValPtr DNS_Mgr::LookupHost(const char* name)
{
if ( mode == DNS_FAKE )
return fake_name_lookup_result(name);
@ -542,7 +542,7 @@ zeek::IntrusivePtr<TableVal> DNS_Mgr::LookupHost(const char* name)
}
}
zeek::IntrusivePtr<Val> DNS_Mgr::LookupAddr(const IPAddr& addr)
ValPtr DNS_Mgr::LookupAddr(const IPAddr& addr)
{
InitSource();
@ -698,7 +698,7 @@ void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* dm)
}
void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* dm,
zeek::IntrusivePtr<ListVal> l1, zeek::IntrusivePtr<ListVal> l2)
ListValPtr l1, ListValPtr l2)
{
if ( ! e )
return;
@ -714,7 +714,7 @@ void DNS_Mgr::Event(EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm)
mgr.Enqueue(e, BuildMappingVal(old_dm), BuildMappingVal(new_dm));
}
zeek::IntrusivePtr<Val> DNS_Mgr::BuildMappingVal(DNS_Mapping* dm)
ValPtr DNS_Mgr::BuildMappingVal(DNS_Mapping* dm)
{
auto r = zeek::make_intrusive<RecordVal>(dm_rec);
@ -870,7 +870,7 @@ 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::IntrusivePtr<ListVal> DNS_Mgr::AddrListDelta(ListVal* al1, ListVal* al2)
ListValPtr DNS_Mgr::AddrListDelta(ListVal* al1, ListVal* al2)
{
auto delta = zeek::make_intrusive<ListVal>(zeek::TYPE_ADDR);
@ -980,7 +980,7 @@ const char* DNS_Mgr::LookupAddrInCache(const IPAddr& addr)
return d->names ? d->names[0] : "<\?\?\?>";
}
zeek::IntrusivePtr<TableVal> 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() )
@ -1030,7 +1030,7 @@ const char* DNS_Mgr::LookupTextInCache(const string& name)
}
static void resolve_lookup_cb(DNS_Mgr::LookupCallback* callback,
zeek::IntrusivePtr<TableVal> result)
TableValPtr result)
{
callback->Resolved(result.get());
delete callback;

18
src/DNS_Mgr.h
View file

@ -21,6 +21,10 @@ class Func;
class EventHandler;
class DNS_Mgr_Request;
using ValPtr = zeek::IntrusivePtr<Val>;
using ListValPtr = zeek::IntrusivePtr<ListVal>;
using TableValPtr = zeek::IntrusivePtr<TableVal>;
ZEEK_FORWARD_DECLARE_NAMESPACED(RecordType, zeek);
typedef PList<DNS_Mgr_Request> DNS_mgr_request_list;
@ -50,9 +54,9 @@ public:
// Looks up the address or addresses of the given host, and returns
// a set of addr.
zeek::IntrusivePtr<TableVal> LookupHost(const char* host);
TableValPtr LookupHost(const char* host);
zeek::IntrusivePtr<Val> LookupAddr(const IPAddr& addr);
ValPtr LookupAddr(const IPAddr& addr);
// Define the directory where to store the data.
void SetDir(const char* arg_dir) { dir = copy_string(arg_dir); }
@ -62,7 +66,7 @@ public:
bool Save();
const char* LookupAddrInCache(const IPAddr& addr);
zeek::IntrusivePtr<TableVal> LookupNameInCache(const std::string& name);
TableValPtr LookupNameInCache(const std::string& name);
const char* LookupTextInCache(const std::string& name);
// Support for async lookups.
@ -100,14 +104,14 @@ protected:
void Event(EventHandlerPtr e, DNS_Mapping* dm);
void Event(EventHandlerPtr e, DNS_Mapping* dm,
zeek::IntrusivePtr<ListVal> l1, zeek::IntrusivePtr<ListVal> l2);
ListValPtr l1, ListValPtr l2);
void Event(EventHandlerPtr e, DNS_Mapping* old_dm, DNS_Mapping* new_dm);
zeek::IntrusivePtr<Val> 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::IntrusivePtr<ListVal> AddrListDelta(ListVal* al1, ListVal* al2);
ListValPtr AddrListDelta(ListVal* al1, ListVal* al2);
void DumpAddrList(FILE* f, ListVal* al);
typedef std::map<std::string, std::pair<DNS_Mapping*, DNS_Mapping*> > HostMap;
@ -151,7 +155,7 @@ protected:
bool did_init;
zeek::IntrusivePtr<zeek::RecordType> dm_rec;
zeek::RecordTypePtr dm_rec;
typedef std::list<LookupCallback*> CallbackList;

4
src/Debug.cc
View file

@ -948,7 +948,7 @@ extern YYLTYPE yylloc; // holds start line and column of token
extern int line_number;
extern const char* filename;
zeek::IntrusivePtr<Val> 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,
@ -983,7 +983,7 @@ zeek::IntrusivePtr<Val> dbg_eval_expr(const char* expr)
yylloc.first_line = yylloc.last_line = line_number = 1;
// Parse the thing into an expr.
zeek::IntrusivePtr<Val> result;
ValPtr result;
if ( yyparse() )
{
if ( g_curr_debug_error )

3
src/Debug.h
View file

@ -16,6 +16,7 @@ template <class T> class IntrusivePtr;
}
class Val;
using ValPtr = zeek::IntrusivePtr<Val>;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
@ -165,7 +166,7 @@ int dbg_handle_debug_input(); // read a line and then have it executed
int dbg_execute_command(const char* cmd);
// Interactive expression evaluation.
zeek::IntrusivePtr<Val> dbg_eval_expr(const char* expr);
ValPtr dbg_eval_expr(const char* expr);
// Extra debugging facilities.
// TODO: current connections, memory allocated, other internal data structures.

9
src/Discard.h
View file

@ -9,6 +9,7 @@
class IP_Hdr;
class Val;
class Func;
using FuncPtr = zeek::IntrusivePtr<Func>;
class Discarder {
public:
@ -22,10 +23,10 @@ public:
protected:
Val* BuildData(const u_char* data, int hdrlen, int len, int caplen);
zeek::IntrusivePtr<Func> check_ip;
zeek::IntrusivePtr<Func> check_tcp;
zeek::IntrusivePtr<Func> check_udp;
zeek::IntrusivePtr<Func> 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;

2
src/Event.h
View file

@ -108,7 +108,7 @@ public:
template <class... Args>
std::enable_if_t<
std::is_convertible_v<
std::tuple_element_t<0, std::tuple<Args...>>, zeek::IntrusivePtr<Val>>>
std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>>
Enqueue(const EventHandlerPtr& h, Args&&... args)
{ return Enqueue(h, zeek::Args{std::forward<Args>(args)...}); }

4
src/EventHandler.cc
View file

@ -26,7 +26,7 @@ EventHandler::operator bool() const
|| ! auto_publish.empty());
}
const zeek::IntrusivePtr<zeek::FuncType>& EventHandler::GetType(bool check_export)
const zeek::FuncTypePtr& EventHandler::GetType(bool check_export)
{
if ( type )
return type;
@ -44,7 +44,7 @@ const zeek::IntrusivePtr<zeek::FuncType>& EventHandler::GetType(bool check_expor
return type;
}
void EventHandler::SetFunc(zeek::IntrusivePtr<Func> f)
void EventHandler::SetFunc(FuncPtr f)
{ local = std::move(f); }
void EventHandler::SetLocalHandler(Func* f)

11
src/EventHandler.h
View file

@ -10,6 +10,7 @@
#include <string>
class Func;
using FuncPtr = zeek::IntrusivePtr<Func>;
class EventHandler {
public:
@ -17,19 +18,19 @@ public:
const char* Name() { return name.data(); }
const zeek::IntrusivePtr<Func>& GetFunc()
const FuncPtr& GetFunc()
{ return local; }
[[deprecated("Remove in v4.1. Use GetFunc().")]]
Func* LocalHandler() { return local.get(); }
const zeek::IntrusivePtr<zeek::FuncType>& GetType(bool check_export = true);
const zeek::FuncTypePtr& GetType(bool check_export = true);
[[deprecated("Remove in v4.1. Use GetType().")]]
zeek::FuncType* FType(bool check_export = true)
{ return GetType().get(); }
void SetFunc(zeek::IntrusivePtr<Func> f);
void SetFunc(FuncPtr f);
[[deprecated("Remove in v4.1. Use SetFunc().")]]
void SetLocalHandler(Func* f);
@ -68,8 +69,8 @@ private:
void NewEvent(zeek::Args* vl); // Raise new_event() meta event.
std::string name;
zeek::IntrusivePtr<Func> local;
zeek::IntrusivePtr<zeek::FuncType> type;
FuncPtr local;
zeek::FuncTypePtr type;
bool used; // this handler is indeed used somewhere
bool enabled;
bool error_handler; // this handler reports error messages.

342
src/Expr.cc
View file

File diff suppressed because it is too large Load diff

332
src/Expr.h
View file

@ -24,6 +24,8 @@ struct function_ingredients;
namespace zeek::detail {
using IDPtr = zeek::IntrusivePtr<ID>;
enum BroExprTag : int {
EXPR_ANY = -1,
EXPR_NAME, EXPR_CONST,
@ -73,12 +75,17 @@ class CallExpr;
class EventExpr;
class Stmt;
class Expr;
using ExprPtr = zeek::IntrusivePtr<Expr>;
using EventExprPtr = zeek::IntrusivePtr<EventExpr>;
using ListExprPtr = zeek::IntrusivePtr<ListExpr>;
class Expr : public BroObj {
public:
[[deprecated("Remove in v4.1. Use GetType().")]]
zeek::Type* Type() const { return type.get(); }
const zeek::IntrusivePtr<zeek::Type>& GetType() const
const zeek::TypePtr& GetType() const
{ return type; }
template <class T>
@ -91,21 +98,20 @@ public:
// Evaluates the expression and returns a corresponding Val*,
// or nil if the expression's value isn't fixed.
virtual zeek::IntrusivePtr<Val> Eval(Frame* f) const = 0;
virtual ValPtr Eval(Frame* f) const = 0;
// Same, but the context is that we are adding an element
// into the given aggregate of the given type. Note that
// return type is void since it's updating an existing
// value, rather than creating a new one.
virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f)
const;
virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const;
// Assign to the given value, if appropriate.
virtual void Assign(Frame* f, zeek::IntrusivePtr<Val> v);
virtual void Assign(Frame* f, ValPtr v);
// Returns the type corresponding to this expression interpreted
// as an initialization. Returns nil if the initialization is illegal.
virtual zeek::IntrusivePtr<zeek::Type> InitType() const;
virtual zeek::TypePtr InitType() const;
// Returns true if this expression, interpreted as an initialization,
// constitutes a record element, false otherwise. If the TypeDecl*
@ -118,7 +124,7 @@ public:
// with the given type. If "aggr" is non-nil, then this expression
// is an element of the given aggregate, and it is added to it
// accordingly.
virtual zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const;
virtual ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const;
// True if the expression has no side effects, false otherwise.
virtual bool IsPure() const;
@ -154,7 +160,7 @@ public:
// Return the expression converted to L-value form. If expr
// cannot be used as an L-value, reports an error and returns
// the current value of expr (this is the default method).
virtual zeek::IntrusivePtr<Expr> MakeLvalue();
virtual ExprPtr MakeLvalue();
// Marks the expression as one requiring (or at least appearing
// with) parentheses. Used for pretty-printing.
@ -223,7 +229,7 @@ protected:
// Puts the expression in canonical form.
virtual void Canonicize();
void SetType(zeek::IntrusivePtr<zeek::Type> t);
void SetType(zeek::TypePtr t);
// Reports the given error and sets the expression's type to
// TYPE_ERROR.
@ -235,19 +241,19 @@ protected:
[[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const;
BroExprTag tag;
zeek::IntrusivePtr<zeek::Type> type;
zeek::TypePtr type;
bool paren;
};
class NameExpr final : public Expr {
public:
explicit NameExpr(zeek::IntrusivePtr<ID> id, bool const_init = false);
explicit NameExpr(zeek::detail::IDPtr id, bool const_init = false);
ID* Id() const { return id.get(); }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
void Assign(Frame* f, zeek::IntrusivePtr<Val> v) override;
zeek::IntrusivePtr<Expr> MakeLvalue() override;
ValPtr Eval(Frame* f) const override;
void Assign(Frame* f, ValPtr v) override;
ExprPtr MakeLvalue() override;
bool IsPure() const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
@ -255,23 +261,23 @@ public:
protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<ID> id;
zeek::detail::IDPtr id;
bool in_const_init;
};
class ConstExpr final : public Expr {
public:
explicit ConstExpr(zeek::IntrusivePtr<Val> val);
explicit ConstExpr(ValPtr val);
Val* Value() const { return val.get(); }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> val;
ValPtr val;
};
class UnaryExpr : public Expr {
@ -281,21 +287,21 @@ public:
// UnaryExpr::Eval correctly handles vector types. Any child
// class that overrides Eval() should be modified to handle
// vectors correctly as necessary.
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
bool IsPure() const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
UnaryExpr(BroExprTag arg_tag, zeek::IntrusivePtr<Expr> arg_op);
UnaryExpr(BroExprTag arg_tag, ExprPtr arg_op);
void ExprDescribe(ODesc* d) const override;
// Returns the expression folded using the given constant.
virtual zeek::IntrusivePtr<Val> Fold(Val* v) const;
virtual ValPtr Fold(Val* v) const;
zeek::IntrusivePtr<Expr> op;
ExprPtr op;
};
class BinaryExpr : public Expr {
@ -308,13 +314,13 @@ public:
// BinaryExpr::Eval correctly handles vector types. Any child
// class that overrides Eval() should be modified to handle
// vectors correctly as necessary.
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
BinaryExpr(BroExprTag arg_tag,
zeek::IntrusivePtr<Expr> arg_op1, zeek::IntrusivePtr<Expr> arg_op2)
ExprPtr arg_op1, ExprPtr arg_op2)
: Expr(arg_tag), op1(std::move(arg_op1)), op2(std::move(arg_op2))
{
if ( ! (op1 && op2) )
@ -324,20 +330,20 @@ protected:
}
// Returns the expression folded using the given constants.
virtual zeek::IntrusivePtr<Val> Fold(Val* v1, Val* v2) const;
virtual ValPtr Fold(Val* v1, Val* v2) const;
// Same for when the constants are strings.
virtual zeek::IntrusivePtr<Val> StringFold(Val* v1, Val* v2) const;
virtual ValPtr StringFold(Val* v1, Val* v2) const;
// Same for when the constants are patterns.
virtual zeek::IntrusivePtr<Val> PatternFold(Val* v1, Val* v2) const;
virtual ValPtr PatternFold(Val* v1, Val* v2) const;
// Same for when the constants are sets.
virtual zeek::IntrusivePtr<Val> SetFold(Val* v1, Val* v2) const;
virtual ValPtr SetFold(Val* v1, Val* v2) const;
// Same for when the constants are addresses or subnets.
virtual zeek::IntrusivePtr<Val> AddrFold(Val* v1, Val* v2) const;
virtual zeek::IntrusivePtr<Val> SubNetFold(Val* v1, Val* v2) const;
virtual ValPtr AddrFold(Val* v1, Val* v2) const;
virtual ValPtr SubNetFold(Val* v1, Val* v2) const;
bool BothConst() const { return op1->IsConst() && op2->IsConst(); }
@ -353,148 +359,148 @@ protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Expr> op1;
zeek::IntrusivePtr<Expr> op2;
ExprPtr op1;
ExprPtr op2;
};
class CloneExpr final : public UnaryExpr {
public:
explicit CloneExpr(zeek::IntrusivePtr<Expr> op);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
explicit CloneExpr(ExprPtr op);
ValPtr Eval(Frame* f) const override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class IncrExpr final : public UnaryExpr {
public:
IncrExpr(BroExprTag tag, zeek::IntrusivePtr<Expr> op);
IncrExpr(BroExprTag tag, ExprPtr op);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
zeek::IntrusivePtr<Val> DoSingleEval(Frame* f, Val* v) const;
ValPtr Eval(Frame* f) const override;
ValPtr DoSingleEval(Frame* f, Val* v) const;
bool IsPure() const override;
};
class ComplementExpr final : public UnaryExpr {
public:
explicit ComplementExpr(zeek::IntrusivePtr<Expr> op);
explicit ComplementExpr(ExprPtr op);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class NotExpr final : public UnaryExpr {
public:
explicit NotExpr(zeek::IntrusivePtr<Expr> op);
explicit NotExpr(ExprPtr op);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class PosExpr final : public UnaryExpr {
public:
explicit PosExpr(zeek::IntrusivePtr<Expr> op);
explicit PosExpr(ExprPtr op);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class NegExpr final : public UnaryExpr {
public:
explicit NegExpr(zeek::IntrusivePtr<Expr> op);
explicit NegExpr(ExprPtr op);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class SizeExpr final : public UnaryExpr {
public:
explicit SizeExpr(zeek::IntrusivePtr<Expr> op);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
explicit SizeExpr(ExprPtr op);
ValPtr Eval(Frame* f) const override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class AddExpr final : public BinaryExpr {
public:
AddExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
AddExpr(ExprPtr op1, ExprPtr op2);
void Canonicize() override;
};
class AddToExpr final : public BinaryExpr {
public:
AddToExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
AddToExpr(ExprPtr op1, ExprPtr op2);
ValPtr Eval(Frame* f) const override;
};
class RemoveFromExpr final : public BinaryExpr {
public:
RemoveFromExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
RemoveFromExpr(ExprPtr op1, ExprPtr op2);
ValPtr Eval(Frame* f) const override;
};
class SubExpr final : public BinaryExpr {
public:
SubExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
SubExpr(ExprPtr op1, ExprPtr op2);
};
class TimesExpr final : public BinaryExpr {
public:
TimesExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
TimesExpr(ExprPtr op1, ExprPtr op2);
void Canonicize() override;
};
class DivideExpr final : public BinaryExpr {
public:
DivideExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
DivideExpr(ExprPtr op1, ExprPtr op2);
protected:
zeek::IntrusivePtr<Val> AddrFold(Val* v1, Val* v2) const override;
ValPtr AddrFold(Val* v1, Val* v2) const override;
};
class ModExpr final : public BinaryExpr {
public:
ModExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
ModExpr(ExprPtr op1, ExprPtr op2);
};
class BoolExpr final : public BinaryExpr {
public:
BoolExpr(BroExprTag tag, zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
BoolExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
zeek::IntrusivePtr<Val> DoSingleEval(Frame* f, zeek::IntrusivePtr<Val> v1, Expr* op2) const;
ValPtr Eval(Frame* f) const override;
ValPtr DoSingleEval(Frame* f, ValPtr v1, Expr* op2) const;
};
class BitExpr final : public BinaryExpr {
public:
BitExpr(BroExprTag tag, zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
BitExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
};
class EqExpr final : public BinaryExpr {
public:
EqExpr(BroExprTag tag, zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
EqExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
void Canonicize() override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
ValPtr Fold(Val* v1, Val* v2) const override;
};
class RelExpr final : public BinaryExpr {
public:
RelExpr(BroExprTag tag, zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
RelExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
void Canonicize() override;
};
class CondExpr final : public Expr {
public:
CondExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2, zeek::IntrusivePtr<Expr> op3);
CondExpr(ExprPtr op1, ExprPtr op2, ExprPtr op3);
const Expr* Op1() const { return op1.get(); }
const Expr* Op2() const { return op2.get(); }
const Expr* Op3() const { return op3.get(); }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
bool IsPure() const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
@ -502,53 +508,53 @@ public:
protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Expr> op1;
zeek::IntrusivePtr<Expr> op2;
zeek::IntrusivePtr<Expr> op3;
ExprPtr op1;
ExprPtr op2;
ExprPtr op3;
};
class RefExpr final : public UnaryExpr {
public:
explicit RefExpr(zeek::IntrusivePtr<Expr> op);
explicit RefExpr(ExprPtr op);
void Assign(Frame* f, zeek::IntrusivePtr<Val> v) override;
zeek::IntrusivePtr<Expr> MakeLvalue() override;
void Assign(Frame* f, ValPtr v) override;
ExprPtr MakeLvalue() override;
};
class AssignExpr : public BinaryExpr {
public:
// If val is given, evaluating this expression will always yield the val
// yet still perform the assignment. Used for triggers.
AssignExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2, bool is_init,
zeek::IntrusivePtr<Val> val = nullptr,
const zeek::IntrusivePtr<Attributes>& attrs = nullptr);
AssignExpr(ExprPtr op1, ExprPtr op2, bool is_init,
ValPtr val = nullptr,
const AttributesPtr& attrs = nullptr);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
zeek::IntrusivePtr<zeek::Type> InitType() const override;
zeek::TypePtr InitType() const override;
bool IsRecordElement(TypeDecl* td) const override;
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
bool IsPure() const override;
protected:
bool TypeCheck(const zeek::IntrusivePtr<Attributes>& attrs = nullptr);
bool TypeCheck(const AttributesPtr& attrs = nullptr);
bool TypeCheckArithmetics(TypeTag bt1, TypeTag bt2);
bool is_init;
zeek::IntrusivePtr<Val> val; // optional
ValPtr val; // optional
};
class IndexSliceAssignExpr final : public AssignExpr {
public:
IndexSliceAssignExpr(zeek::IntrusivePtr<Expr> op1,
zeek::IntrusivePtr<Expr> op2, bool is_init);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
IndexSliceAssignExpr(ExprPtr op1,
ExprPtr op2, bool is_init);
ValPtr Eval(Frame* f) const override;
};
class IndexExpr final : public BinaryExpr {
public:
IndexExpr(zeek::IntrusivePtr<Expr> op1,
zeek::IntrusivePtr<ListExpr> op2, bool is_slice = false);
IndexExpr(ExprPtr op1,
ListExprPtr op2, bool is_slice = false);
bool CanAdd() const override;
bool CanDel() const override;
@ -556,19 +562,19 @@ public:
void Add(Frame* f) override;
void Delete(Frame* f) override;
void Assign(Frame* f, zeek::IntrusivePtr<Val> v) override;
zeek::IntrusivePtr<Expr> MakeLvalue() override;
void Assign(Frame* f, ValPtr v) override;
ExprPtr MakeLvalue() override;
// Need to override Eval since it can take a vector arg but does
// not necessarily return a vector.
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
bool IsSlice() const { return is_slice; }
protected:
zeek::IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
ValPtr Fold(Val* v1, Val* v2) const override;
void ExprDescribe(ODesc* d) const override;
@ -577,7 +583,7 @@ protected:
class FieldExpr final : public UnaryExpr {
public:
FieldExpr(zeek::IntrusivePtr<Expr> op, const char* field_name);
FieldExpr(ExprPtr op, const char* field_name);
~FieldExpr() override;
int Field() const { return field; }
@ -585,13 +591,13 @@ public:
bool CanDel() const override;
void Assign(Frame* f, zeek::IntrusivePtr<Val> v) override;
void Assign(Frame* f, ValPtr v) override;
void Delete(Frame* f) override;
zeek::IntrusivePtr<Expr> MakeLvalue() override;
ExprPtr MakeLvalue() override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
@ -604,13 +610,13 @@ protected:
// "rec?$$attrname" is true if the attribute attrname is not nil.
class HasFieldExpr final : public UnaryExpr {
public:
HasFieldExpr(zeek::IntrusivePtr<Expr> op, const char* field_name);
HasFieldExpr(ExprPtr op, const char* field_name);
~HasFieldExpr() override;
const char* FieldName() const { return field_name; }
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
@ -620,76 +626,76 @@ protected:
class RecordConstructorExpr final : public UnaryExpr {
public:
explicit RecordConstructorExpr(zeek::IntrusivePtr<ListExpr> constructor_list);
explicit RecordConstructorExpr(ListExprPtr constructor_list);
~RecordConstructorExpr() override;
protected:
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
ValPtr Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
};
class TableConstructorExpr final : public UnaryExpr {
public:
TableConstructorExpr(zeek::IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<zeek::IntrusivePtr<Attr>>> attrs,
zeek::IntrusivePtr<zeek::Type> arg_type = nullptr);
TableConstructorExpr(ListExprPtr constructor_list,
std::unique_ptr<std::vector<AttrPtr>> attrs,
zeek::TypePtr arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); }
const zeek::IntrusivePtr<Attributes>& GetAttrs() const
const AttributesPtr& GetAttrs() const
{ return attrs; }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
protected:
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Attributes> attrs;
AttributesPtr attrs;
};
class SetConstructorExpr final : public UnaryExpr {
public:
SetConstructorExpr(zeek::IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<zeek::IntrusivePtr<Attr>>> attrs,
zeek::IntrusivePtr<zeek::Type> arg_type = nullptr);
SetConstructorExpr(ListExprPtr constructor_list,
std::unique_ptr<std::vector<AttrPtr>> attrs,
zeek::TypePtr arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); }
const zeek::IntrusivePtr<Attributes>& GetAttrs() const
const AttributesPtr& GetAttrs() const
{ return attrs; }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
protected:
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Attributes> attrs;
AttributesPtr attrs;
};
class VectorConstructorExpr final : public UnaryExpr {
public:
explicit VectorConstructorExpr(zeek::IntrusivePtr<ListExpr> constructor_list,
zeek::IntrusivePtr<zeek::Type> arg_type = nullptr);
explicit VectorConstructorExpr(ListExprPtr constructor_list,
zeek::TypePtr arg_type = nullptr);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
protected:
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
void ExprDescribe(ODesc* d) const override;
};
class FieldAssignExpr final : public UnaryExpr {
public:
FieldAssignExpr(const char* field_name, zeek::IntrusivePtr<Expr> value);
FieldAssignExpr(const char* field_name, ExprPtr value);
const char* FieldName() const { return field_name.c_str(); }
@ -704,21 +710,21 @@ protected:
class ArithCoerceExpr final : public UnaryExpr {
public:
ArithCoerceExpr(zeek::IntrusivePtr<Expr> op, zeek::TypeTag t);
ArithCoerceExpr(ExprPtr op, zeek::TypeTag t);
protected:
zeek::IntrusivePtr<Val> FoldSingleVal(Val* v, InternalTypeTag t) const;
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr FoldSingleVal(Val* v, InternalTypeTag t) const;
ValPtr Fold(Val* v) const override;
};
class RecordCoerceExpr final : public UnaryExpr {
public:
RecordCoerceExpr(zeek::IntrusivePtr<Expr> op, zeek::IntrusivePtr<RecordType> r);
RecordCoerceExpr(ExprPtr op, RecordTypePtr r);
~RecordCoerceExpr() override;
protected:
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
ValPtr Fold(Val* v) const override;
// For each super-record slot, gives subrecord slot with which to
// fill it.
@ -728,20 +734,20 @@ protected:
class TableCoerceExpr final : public UnaryExpr {
public:
TableCoerceExpr(zeek::IntrusivePtr<Expr> op, zeek::IntrusivePtr<TableType> r);
TableCoerceExpr(ExprPtr op, TableTypePtr r);
~TableCoerceExpr() override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class VectorCoerceExpr final : public UnaryExpr {
public:
VectorCoerceExpr(zeek::IntrusivePtr<Expr> op, zeek::IntrusivePtr<VectorType> v);
VectorCoerceExpr(ExprPtr op, VectorTypePtr v);
~VectorCoerceExpr() override;
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
};
class ScheduleTimer final : public Timer {
@ -758,11 +764,11 @@ protected:
class ScheduleExpr final : public Expr {
public:
ScheduleExpr(zeek::IntrusivePtr<Expr> when, zeek::IntrusivePtr<EventExpr> event);
ScheduleExpr(ExprPtr when, EventExprPtr event);
bool IsPure() const override;
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
Expr* When() const { return when.get(); }
EventExpr* Event() const { return event.get(); }
@ -772,22 +778,22 @@ public:
protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Expr> when;
zeek::IntrusivePtr<EventExpr> event;
ExprPtr when;
EventExprPtr event;
};
class InExpr final : public BinaryExpr {
public:
InExpr(zeek::IntrusivePtr<Expr> op1, zeek::IntrusivePtr<Expr> op2);
InExpr(ExprPtr op1, ExprPtr op2);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
ValPtr Fold(Val* v1, Val* v2) const override;
};
class CallExpr final : public Expr {
public:
CallExpr(zeek::IntrusivePtr<Expr> func, zeek::IntrusivePtr<ListExpr> args,
CallExpr(ExprPtr func, ListExprPtr args,
bool in_hook = false);
Expr* Func() const { return func.get(); }
@ -795,15 +801,15 @@ public:
bool IsPure() const override;
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
void ExprDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Expr> func;
zeek::IntrusivePtr<ListExpr> args;
ExprPtr func;
ListExprPtr args;
};
@ -817,7 +823,7 @@ public:
LambdaExpr(std::unique_ptr<function_ingredients> ingredients,
id_list outer_ids);
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
Scope* GetScope() const;
@ -834,13 +840,13 @@ private:
class EventExpr final : public Expr {
public:
EventExpr(const char* name, zeek::IntrusivePtr<ListExpr> args);
EventExpr(const char* name, ListExprPtr args);
const char* Name() const { return name.c_str(); }
ListExpr* Args() const { return args.get(); }
EventHandlerPtr Handler() const { return handler; }
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
@ -849,16 +855,16 @@ protected:
std::string name;
EventHandlerPtr handler;
zeek::IntrusivePtr<ListExpr> args;
ListExprPtr args;
};
class ListExpr : public Expr {
public:
ListExpr();
explicit ListExpr(zeek::IntrusivePtr<Expr> e);
explicit ListExpr(ExprPtr e);
~ListExpr() override;
void Append(zeek::IntrusivePtr<Expr> e);
void Append(ExprPtr e);
const expr_list& Exprs() const { return exprs; }
expr_list& Exprs() { return exprs; }
@ -866,17 +872,17 @@ public:
// True if the entire list represents pure values.
bool IsPure() const override;
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
zeek::IntrusivePtr<zeek::Type> InitType() const override;
zeek::IntrusivePtr<Val> InitVal(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const override;
zeek::IntrusivePtr<Expr> MakeLvalue() override;
void Assign(Frame* f, zeek::IntrusivePtr<Val> v) override;
zeek::TypePtr InitType() const override;
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
ExprPtr MakeLvalue() override;
void Assign(Frame* f, ValPtr v) override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Val> AddSetInit(const zeek::Type* t, zeek::IntrusivePtr<Val> aggr) const;
ValPtr AddSetInit(const zeek::Type* t, ValPtr aggr) const;
void ExprDescribe(ODesc* d) const override;
@ -886,28 +892,28 @@ protected:
class RecordAssignExpr final : public ListExpr {
public:
RecordAssignExpr(const zeek::IntrusivePtr<Expr>& record, const zeek::IntrusivePtr<Expr>& init_list, bool is_init);
RecordAssignExpr(const ExprPtr& record, const ExprPtr& init_list, bool is_init);
};
class CastExpr final : public UnaryExpr {
public:
CastExpr(zeek::IntrusivePtr<Expr> op, zeek::IntrusivePtr<zeek::Type> t);
CastExpr(ExprPtr op, zeek::TypePtr t);
protected:
zeek::IntrusivePtr<Val> Eval(Frame* f) const override;
ValPtr Eval(Frame* f) const override;
void ExprDescribe(ODesc* d) const override;
};
class IsExpr final : public UnaryExpr {
public:
IsExpr(zeek::IntrusivePtr<Expr> op, zeek::IntrusivePtr<zeek::Type> t);
IsExpr(ExprPtr op, zeek::TypePtr t);
protected:
zeek::IntrusivePtr<Val> Fold(Val* v) const override;
ValPtr Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
private:
zeek::IntrusivePtr<zeek::Type> t;
zeek::TypePtr t;
};
inline Val* Expr::ExprVal() const
@ -918,9 +924,9 @@ inline Val* Expr::ExprVal() const
}
// Decides whether to return an AssignExpr or a RecordAssignExpr.
zeek::IntrusivePtr<Expr> get_assign_expr(
zeek::IntrusivePtr<Expr> op1,
zeek::IntrusivePtr<Expr> op2, bool is_init);
ExprPtr get_assign_expr(
ExprPtr op1,
ExprPtr op2, bool is_init);
// Type-check the given expression(s) against the given type(s). Complain
// if the expression cannot match the given type, returning 0. If it can
@ -937,7 +943,7 @@ zeek::IntrusivePtr<Expr> get_assign_expr(
* Returns nullptr if the expression cannot match or a promoted
* expression.
*/
extern zeek::IntrusivePtr<Expr> check_and_promote_expr(Expr* e, Type* t);
extern ExprPtr check_and_promote_expr(Expr* e, Type* t);
extern bool check_and_promote_exprs(ListExpr* elements, TypeList* types);
extern bool check_and_promote_args(ListExpr* args, RecordType* types);
@ -945,7 +951,7 @@ extern bool check_and_promote_exprs_to_type(ListExpr* elements, Type* type);
// Returns a ListExpr simplified down to a list a values, or nil
// if they couldn't all be reduced.
std::optional<std::vector<zeek::IntrusivePtr<Val>>> eval_list(Frame* f, const ListExpr* l);
std::optional<std::vector<ValPtr>> eval_list(Frame* f, const ListExpr* l);
// Returns true if e1 is "greater" than e2 - here "greater" is just
// a heuristic, used with commutative operators to put them into
@ -954,7 +960,7 @@ extern bool expr_greater(const Expr* e1, const Expr* e2);
// True if the given Expr* has a vector type
inline bool is_vector(Expr* e) { return e->GetType()->Tag() == TYPE_VECTOR; }
inline bool is_vector(const zeek::IntrusivePtr<Expr>& e) { return is_vector(e.get()); }
inline bool is_vector(const ExprPtr& e) { return is_vector(e.get()); }
}

4
src/File.cc
View file

@ -328,7 +328,7 @@ void BroFile::RaiseOpenEvent()
if ( ! ::file_opened )
return;
zeek::IntrusivePtr<BroFile> bf{zeek::NewRef{}, this};
BroFilePtr bf{zeek::NewRef{}, this};
Event* event = new ::Event(::file_opened, {zeek::make_intrusive<Val>(std::move(bf))});
mgr.Dispatch(event, true);
}
@ -346,7 +346,7 @@ double BroFile::Size()
return s.st_size;
}
zeek::IntrusivePtr<BroFile> BroFile::Get(const char* name)
BroFilePtr BroFile::Get(const char* name)
{
for ( const auto &el : open_files )
if ( el.first == name )

14
src/File.h
View file

@ -18,12 +18,18 @@
class RecordVal;
namespace zeek { class Type; }
namespace zeek {
class Type;
using TypePtr = zeek::IntrusivePtr<zeek::Type>;
}
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
ZEEK_FORWARD_DECLARE_NAMESPACED(PrintStmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail);
class BroFile;
using BroFilePtr = zeek::IntrusivePtr<BroFile>;
class BroFile final : public BroObj {
public:
explicit BroFile(FILE* arg_f);
@ -45,7 +51,7 @@ public:
[[deprecated("Remove in v4.1. Use GetType().")]]
zeek::Type* FType() const { return t.get(); }
const zeek::IntrusivePtr<zeek::Type>& GetType() const
const zeek::TypePtr& GetType() const
{ return t; }
// Whether the file is open in a general sense; it might
@ -72,7 +78,7 @@ public:
static void CloseOpenFiles();
// Get the file with the given name, opening it if it doesn't yet exist.
static zeek::IntrusivePtr<BroFile> Get(const char* name);
static BroFilePtr Get(const char* name);
[[deprecated("Remove in v4.1. Use BroFile::Get().")]]
static BroFile* GetFile(const char* name)
{ return Get(name).release(); }
@ -106,7 +112,7 @@ protected:
void RaiseOpenEvent();
FILE* f;
zeek::IntrusivePtr<zeek::Type> t;
zeek::TypePtr t;
char* name;
char* access;
zeek::detail::Attributes* attrs;

15
src/Frame.cc
View file

@ -7,7 +7,6 @@
#include "Func.h"
#include "Desc.h"
#include "IntrusivePtr.h"
#include "Trigger.h"
#include "Val.h"
#include "ID.h"
@ -65,7 +64,7 @@ void Frame::AddFunctionWithClosureRef(BroFunc* func)
void Frame::SetElement(int n, Val* v)
{ SetElement(n, {zeek::AdoptRef{}, v}); }
void Frame::SetElement(int n, zeek::IntrusivePtr<Val> v)
void Frame::SetElement(int n, ValPtr v)
{
ClearElement(n);
frame[n] = {std::move(v), false};
@ -77,7 +76,7 @@ void Frame::SetElementWeak(int n, Val* v)
frame[n] = {{zeek::AdoptRef{}, v}, true};
}
void Frame::SetElement(const zeek::detail::ID* id, zeek::IntrusivePtr<Val> v)
void Frame::SetElement(const zeek::detail::ID* id, ValPtr v)
{
if ( closure )
{
@ -106,7 +105,7 @@ void Frame::SetElement(const zeek::detail::ID* id, zeek::IntrusivePtr<Val> v)
SetElement(id->Offset(), std::move(v));
}
const zeek::IntrusivePtr<Val>& Frame::GetElementByID(const zeek::detail::ID* id) const
const ValPtr& Frame::GetElementByID(const zeek::detail::ID* id) const
{
if ( closure )
{
@ -173,7 +172,7 @@ Frame* Frame::Clone() const
return other;
}
static bool val_is_func(const zeek::IntrusivePtr<Val>& v, BroFunc* func)
static bool val_is_func(const ValPtr& v, BroFunc* func)
{
if ( v->GetType()->Tag() != zeek::TYPE_FUNC )
return false;
@ -348,14 +347,14 @@ broker::expected<broker::data> Frame::Serialize(const Frame* target, const id_li
return {std::move(rval)};
}
std::pair<bool, zeek::IntrusivePtr<Frame>> Frame::Unserialize(const broker::vector& data)
std::pair<bool, FramePtr> Frame::Unserialize(const broker::vector& data)
{
if ( data.size() == 0 )
return std::make_pair(true, nullptr);
id_list outer_ids;
OffsetMap offset_map;
zeek::IntrusivePtr<Frame> closure;
FramePtr closure;
auto where = data.begin();
@ -505,7 +504,7 @@ void Frame::CaptureClosure(Frame* c, id_list arg_outer_ids)
// if (c) closure = c->SelectiveClone(outer_ids);
}
void Frame::SetTrigger(zeek::IntrusivePtr<zeek::detail::trigger::Trigger> arg_trigger)
void Frame::SetTrigger(zeek::detail::trigger::TriggerPtr arg_trigger)
{
trigger = std::move(arg_trigger);
}

33
src/Frame.h
View file

@ -21,6 +21,19 @@ class BroFunc;
ZEEK_FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Trigger, zeek::detail::trigger);
namespace zeek::detail {
using IDPtr = zeek::IntrusivePtr<ID>;
namespace trigger {
using TriggerPtr = zeek::IntrusivePtr<Trigger>;
}
}
using ValPtr = zeek::IntrusivePtr<Val>;
class Frame;
using FramePtr = zeek::IntrusivePtr<Frame>;
class Frame : public BroObj {
public:
/**
@ -43,7 +56,7 @@ public:
* @param n the index to get.
* @return the value at index *n* of the underlying array.
*/
const zeek::IntrusivePtr<Val>& GetElement(int n) const
const ValPtr& GetElement(int n) const
{ return frame[n].val; }
[[deprecated("Remove in v4.1. Use GetElement(int).")]]
@ -54,7 +67,7 @@ public:
* @param n the index to set
* @param v the value to set it to
*/
void SetElement(int n, zeek::IntrusivePtr<Val> v);
void SetElement(int n, ValPtr v);
[[deprecated("Remove in v4.1. Pass IntrusivePtr instead.")]]
void SetElement(int n, Val* v);
@ -66,8 +79,8 @@ public:
* @param id the ID to associate
* @param v the value to associate it with
*/
void SetElement(const zeek::detail::ID* id, zeek::IntrusivePtr<Val> v);
void SetElement(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::IntrusivePtr<Val> v)
void SetElement(const zeek::detail::ID* id, ValPtr v);
void SetElement(const zeek::detail::IDPtr& id, ValPtr v)
{ SetElement(id.get(), std::move(v)); }
/**
@ -77,7 +90,7 @@ public:
* @param id the id who's value to retreive
* @return the value associated with *id*
*/
const zeek::IntrusivePtr<Val>& GetElementByID(const zeek::IntrusivePtr<zeek::detail::ID>& id) const
const ValPtr& GetElementByID(const zeek::detail::IDPtr& id) const
{ return GetElementByID(id.get()); }
[[deprecated("Remove in v4.1. Use GetElementByID().")]]
@ -195,7 +208,7 @@ public:
* and the second is the unserialized frame with reference count +1, or
* null if the serialization wasn't successful.
*/
static std::pair<bool, zeek::IntrusivePtr<Frame>> Unserialize(const broker::vector& data);
static std::pair<bool, FramePtr> Unserialize(const broker::vector& data);
/**
* Sets the IDs that the frame knows offsets for. These offsets will
@ -216,7 +229,7 @@ public:
// If the frame is run in the context of a trigger condition evaluation,
// the trigger needs to be registered.
void SetTrigger(zeek::IntrusivePtr<zeek::detail::trigger::Trigger> arg_trigger);
void SetTrigger(zeek::detail::trigger::TriggerPtr arg_trigger);
void ClearTrigger();
zeek::detail::trigger::Trigger* GetTrigger() const { return trigger.get(); }
@ -241,13 +254,13 @@ private:
using OffsetMap = std::unordered_map<std::string, int>;
struct Element {
zeek::IntrusivePtr<Val> val;
ValPtr val;
// Weak reference is used to prevent circular reference memory leaks
// in lambdas/closures.
bool weak_ref;
};
const zeek::IntrusivePtr<Val>& GetElementByID(const zeek::detail::ID* id) const;
const ValPtr& GetElementByID(const zeek::detail::ID* id) const;
/**
* Sets the element at index *n* of the underlying array to *v*, but does
@ -322,7 +335,7 @@ private:
/** The next statement to be evaluted in the context of this frame. */
zeek::detail::Stmt* next_stmt;
zeek::IntrusivePtr<zeek::detail::trigger::Trigger> trigger;
zeek::detail::trigger::TriggerPtr trigger;
const zeek::detail::CallExpr* call;
std::unique_ptr<std::vector<BroFunc*>> functions_with_closure_frame_reference;

42
src/Func.cc
View file

@ -60,7 +60,7 @@ extern RETSIGTYPE sig_handler(int signo);
std::vector<CallInfo> call_stack;
bool did_builtin_init = false;
static const std::pair<bool, zeek::IntrusivePtr<Val>> empty_hook_result(false, nullptr);
static const std::pair<bool, ValPtr> empty_hook_result(false, nullptr);
std::string render_call_stack()
{
@ -122,19 +122,19 @@ Func::Func(Kind arg_kind) : kind(arg_kind)
Func::~Func() = default;
void Func::AddBody(zeek::IntrusivePtr<zeek::detail::Stmt> /* new_body */,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& /* new_inits */,
void Func::AddBody(zeek::detail::StmtPtr /* new_body */,
const std::vector<zeek::detail::IDPtr>& /* new_inits */,
size_t /* new_frame_size */, int /* priority */)
{
Internal("Func::AddBody called");
}
void Func::SetScope(zeek::IntrusivePtr<Scope> newscope)
void Func::SetScope(ScopePtr newscope)
{
scope = std::move(newscope);
}
zeek::IntrusivePtr<Func> Func::DoClone()
FuncPtr Func::DoClone()
{
// By default, ok just to return a reference. Func does not have any state
// that is different across instances.
@ -216,7 +216,7 @@ void Func::CopyStateInto(Func* other) const
other->unique_id = unique_id;
}
void Func::CheckPluginResult(bool handled, const zeek::IntrusivePtr<Val>& hook_result,
void Func::CheckPluginResult(bool handled, const ValPtr& hook_result,
zeek::FunctionFlavor flavor) const
{
// Helper function factoring out this code from BroFunc:Call() for
@ -269,8 +269,8 @@ void Func::CheckPluginResult(bool handled, const zeek::IntrusivePtr<Val>& hook_r
}
}
BroFunc::BroFunc(const zeek::IntrusivePtr<zeek::detail::ID>& arg_id, zeek::IntrusivePtr<zeek::detail::Stmt> arg_body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& aggr_inits,
BroFunc::BroFunc(const zeek::detail::IDPtr& arg_id, zeek::detail::StmtPtr arg_body,
const std::vector<zeek::detail::IDPtr>& aggr_inits,
size_t arg_frame_size, int priority)
: Func(BRO_FUNC)
{
@ -305,7 +305,7 @@ Val* Func::Call(val_list* args, Frame* parent) const
return Invoke(&zargs, parent).release();
};
zeek::IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
ValPtr BroFunc::Invoke(zeek::Args* args, Frame* parent) const
{
#ifdef PROFILE_BRO_FUNCTIONS
DEBUG_MSG("Function: %s\n", Name());
@ -357,7 +357,7 @@ zeek::IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
}
stmt_flow_type flow = FLOW_NEXT;
zeek::IntrusivePtr<Val> result;
ValPtr result;
for ( const auto& body : bodies )
{
@ -450,8 +450,8 @@ zeek::IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
return result;
}
void BroFunc::AddBody(zeek::IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& new_inits,
void BroFunc::AddBody(zeek::detail::StmtPtr new_body,
const std::vector<zeek::detail::IDPtr>& new_inits,
size_t new_frame_size, int priority)
{
if ( new_frame_size > frame_size )
@ -541,7 +541,7 @@ bool BroFunc::UpdateClosure(const broker::vector& data)
}
zeek::IntrusivePtr<Func> BroFunc::DoClone()
FuncPtr BroFunc::DoClone()
{
// BroFunc could hold a closure. In this case a clone of it must
// store a copy of this closure.
@ -575,9 +575,9 @@ void BroFunc::Describe(ODesc* d) const
}
}
zeek::IntrusivePtr<zeek::detail::Stmt> BroFunc::AddInits(
zeek::IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& inits)
zeek::detail::StmtPtr BroFunc::AddInits(
zeek::detail::StmtPtr body,
const std::vector<zeek::detail::IDPtr>& inits)
{
if ( inits.empty() )
return body;
@ -616,7 +616,7 @@ bool BuiltinFunc::IsPure() const
return is_pure;
}
zeek::IntrusivePtr<Val> BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
ValPtr BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
{
#ifdef PROFILE_BRO_FUNCTIONS
DEBUG_MSG("Function: %s\n", Name());
@ -667,10 +667,10 @@ void BuiltinFunc::Describe(ODesc* d) const
void builtin_error(const char* msg)
{
builtin_error(msg, zeek::IntrusivePtr<Val>{});
builtin_error(msg, ValPtr{});
}
void builtin_error(const char* msg, zeek::IntrusivePtr<Val> arg)
void builtin_error(const char* msg, ValPtr arg)
{
builtin_error(msg, arg.get());
}
@ -846,7 +846,7 @@ 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<zeek::IntrusivePtr<zeek::detail::Attr>>& attrs)
static int get_func_priority(const std::vector<zeek::detail::AttrPtr>& attrs)
{
int priority = 0;
@ -881,7 +881,7 @@ static int get_func_priority(const std::vector<zeek::IntrusivePtr<zeek::detail::
return priority;
}
function_ingredients::function_ingredients(zeek::IntrusivePtr<Scope> scope, zeek::IntrusivePtr<zeek::detail::Stmt> body)
function_ingredients::function_ingredients(ScopePtr scope, zeek::detail::StmtPtr body)
{
frame_size = scope->Length();
inits = scope->GetInits();

71
src/Func.h
View file

@ -20,12 +20,18 @@
class Val;
class Frame;
class Scope;
using ScopePtr = zeek::IntrusivePtr<Scope>;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(FuncType, zeek);
namespace zeek::detail {
using IDPtr = zeek::IntrusivePtr<ID>;
using StmtPtr = zeek::IntrusivePtr<Stmt>;
}
namespace caf {
template <class> class expected;
}
@ -36,9 +42,12 @@ using vector = std::vector<data>;
using caf::expected;
}
class Func;
using FuncPtr = zeek::IntrusivePtr<Func>;
class Func : public BroObj {
public:
static inline const zeek::IntrusivePtr<Func> nil;
static inline const FuncPtr nil;
enum Kind { BRO_FUNC, BUILTIN_FUNC };
@ -50,7 +59,7 @@ public:
zeek::FunctionFlavor Flavor() const { return GetType()->Flavor(); }
struct Body {
zeek::IntrusivePtr<zeek::detail::Stmt> stmts;
zeek::detail::StmtPtr stmts;
int priority;
bool operator<(const Body& other) const
{ return priority > other.priority; } // reverse sort
@ -68,7 +77,7 @@ public:
* @param parent the frame from which the function is being called.
* @return the return value of the function call.
*/
virtual zeek::IntrusivePtr<Val> Invoke(
virtual ValPtr Invoke(
zeek::Args* args, Frame* parent = nullptr) const = 0;
/**
@ -77,8 +86,8 @@ public:
template <class... Args>
std::enable_if_t<
std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>,
zeek::IntrusivePtr<Val>>,
zeek::IntrusivePtr<Val>>
ValPtr>,
ValPtr>
Invoke(Args&&... args) const
{
auto zargs = zeek::Args{std::forward<Args>(args)...};
@ -86,17 +95,17 @@ public:
}
// Add a new event handler to an existing function (event).
virtual void AddBody(zeek::IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& new_inits,
virtual void AddBody(zeek::detail::StmtPtr new_body,
const std::vector<zeek::detail::IDPtr>& new_inits,
size_t new_frame_size, int priority = 0);
virtual void SetScope(zeek::IntrusivePtr<Scope> newscope);
virtual void SetScope(ScopePtr newscope);
virtual Scope* GetScope() const { return scope.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]]
virtual zeek::FuncType* FType() const { return type.get(); }
const zeek::IntrusivePtr<zeek::FuncType>& GetType() const
const zeek::FuncTypePtr& GetType() const
{ return type; }
Kind GetKind() const { return kind; }
@ -107,12 +116,12 @@ public:
void Describe(ODesc* d) const override = 0;
virtual void DescribeDebug(ODesc* d, const zeek::Args* args) const;
virtual zeek::IntrusivePtr<Func> DoClone();
virtual FuncPtr DoClone();
virtual TraversalCode Traverse(TraversalCallback* cb) const;
uint32_t GetUniqueFuncID() const { return unique_id; }
static const zeek::IntrusivePtr<Func>& GetFuncPtrByID(uint32_t id)
static const FuncPtr& GetFuncPtrByID(uint32_t id)
{ return id >= unique_ids.size() ? Func::nil : unique_ids[id]; }
protected:
@ -122,29 +131,29 @@ protected:
void CopyStateInto(Func* other) const;
// Helper function for checking result of plugin hook.
void CheckPluginResult(bool handled, const zeek::IntrusivePtr<Val>& hook_result,
void CheckPluginResult(bool handled, const ValPtr& hook_result,
zeek::FunctionFlavor flavor) const;
std::vector<Body> bodies;
zeek::IntrusivePtr<Scope> scope;
ScopePtr scope;
Kind kind;
uint32_t unique_id;
zeek::IntrusivePtr<zeek::FuncType> type;
zeek::FuncTypePtr type;
std::string name;
static inline std::vector<zeek::IntrusivePtr<Func>> unique_ids;
static inline std::vector<FuncPtr> unique_ids;
};
class BroFunc final : public Func {
public:
BroFunc(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& inits,
BroFunc(const zeek::detail::IDPtr& id, zeek::detail::StmtPtr body,
const std::vector<zeek::detail::IDPtr>& inits,
size_t frame_size, int priority);
~BroFunc() override;
bool IsPure() const override;
zeek::IntrusivePtr<Val> Invoke(zeek::Args* args, Frame* parent) const override;
ValPtr Invoke(zeek::Args* args, Frame* parent) const override;
/**
* Adds adds a closure to the function. Closures are cloned and
@ -175,8 +184,8 @@ public:
*/
broker::expected<broker::data> SerializeClosure() const;
void AddBody(zeek::IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& new_inits,
void AddBody(zeek::detail::StmtPtr new_body,
const std::vector<zeek::detail::IDPtr>& new_inits,
size_t new_frame_size, int priority) override;
/** Sets this function's outer_id list. */
@ -187,14 +196,14 @@ public:
protected:
BroFunc() : Func(BRO_FUNC) {}
zeek::IntrusivePtr<zeek::detail::Stmt> AddInits(
zeek::IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<zeek::IntrusivePtr<zeek::detail::ID>>& inits);
zeek::detail::StmtPtr AddInits(
zeek::detail::StmtPtr body,
const std::vector<zeek::detail::IDPtr>& inits);
/**
* Clones this function along with its closures.
*/
zeek::IntrusivePtr<Func> DoClone() override;
FuncPtr DoClone() override;
/**
* Performs a selective clone of *f* using the IDs that were
@ -222,7 +231,7 @@ public:
~BuiltinFunc() override;
bool IsPure() const override;
zeek::IntrusivePtr<Val> Invoke(zeek::Args* args, 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;
@ -236,7 +245,7 @@ protected:
extern void builtin_error(const char* msg);
extern void builtin_error(const char* msg, zeek::IntrusivePtr<Val>);
extern void builtin_error(const char* msg, ValPtr);
extern void builtin_error(const char* msg, BroObj* arg);
extern void init_builtin_funcs();
extern void init_builtin_funcs_subdirs();
@ -255,14 +264,14 @@ struct function_ingredients {
// Gathers all of the information from a scope and a function body needed
// to build a function.
function_ingredients(zeek::IntrusivePtr<Scope> scope, zeek::IntrusivePtr<zeek::detail::Stmt> body);
function_ingredients(ScopePtr scope, zeek::detail::StmtPtr body);
zeek::IntrusivePtr<zeek::detail::ID> id;
zeek::IntrusivePtr<zeek::detail::Stmt> body;
std::vector<zeek::IntrusivePtr<zeek::detail::ID>> inits;
zeek::detail::IDPtr id;
zeek::detail::StmtPtr body;
std::vector<zeek::detail::IDPtr> inits;
int frame_size;
int priority;
zeek::IntrusivePtr<Scope> scope;
ScopePtr scope;
};
extern std::vector<CallInfo> call_stack;

57
src/ID.cc
View file

@ -1,3 +1,4 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include "zeek-config.h"
@ -19,24 +20,24 @@
#include "zeekygen/ScriptInfo.h"
#include "module_util.h"
zeek::IntrusivePtr<zeek::RecordType> zeek::id::conn_id;
zeek::IntrusivePtr<zeek::RecordType> zeek::id::endpoint;
zeek::IntrusivePtr<zeek::RecordType> zeek::id::connection;
zeek::IntrusivePtr<zeek::RecordType> zeek::id::fa_file;
zeek::IntrusivePtr<zeek::RecordType> zeek::id::fa_metadata;
zeek::IntrusivePtr<zeek::EnumType> zeek::id::transport_proto;
zeek::IntrusivePtr<zeek::TableType> zeek::id::string_set;
zeek::IntrusivePtr<zeek::TableType> zeek::id::string_array;
zeek::IntrusivePtr<zeek::TableType> zeek::id::count_set;
zeek::IntrusivePtr<zeek::VectorType> zeek::id::string_vec;
zeek::IntrusivePtr<zeek::VectorType> zeek::id::index_vec;
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;
const zeek::IntrusivePtr<zeek::detail::ID>& zeek::id::find(std::string_view name)
const zeek::detail::IDPtr& zeek::id::find(std::string_view name)
{
return global_scope()->Find(name);
}
const zeek::IntrusivePtr<zeek::Type>& zeek::id::find_type(std::string_view name)
const zeek::TypePtr& zeek::id::find_type(std::string_view name)
{
auto id = global_scope()->Find(name);
@ -47,7 +48,7 @@ const zeek::IntrusivePtr<zeek::Type>& zeek::id::find_type(std::string_view name)
return id->GetType();
}
const zeek::IntrusivePtr<Val>& zeek::id::find_val(std::string_view name)
const ValPtr& zeek::id::find_val(std::string_view name)
{
auto id = global_scope()->Find(name);
@ -58,7 +59,7 @@ const zeek::IntrusivePtr<Val>& zeek::id::find_val(std::string_view name)
return id->GetVal();
}
const zeek::IntrusivePtr<Val>& zeek::id::find_const(std::string_view name)
const ValPtr& zeek::id::find_const(std::string_view name)
{
auto id = global_scope()->Find(name);
@ -73,7 +74,7 @@ const zeek::IntrusivePtr<Val>& zeek::id::find_const(std::string_view name)
return id->GetVal();
}
zeek::IntrusivePtr<Func> zeek::id::find_func(std::string_view name)
FuncPtr zeek::id::find_func(std::string_view name)
{
const auto& v = zeek::id::find_val(name);
@ -130,7 +131,7 @@ std::string ID::ModuleName() const
return extract_module_name(name);
}
void ID::SetType(zeek::IntrusivePtr<zeek::Type> t)
void ID::SetType(zeek::TypePtr t)
{
type = std::move(t);
}
@ -140,7 +141,7 @@ void ID::ClearVal()
val = nullptr;
}
void ID::SetVal(zeek::IntrusivePtr<Val> v)
void ID::SetVal(ValPtr v)
{
val = std::move(v);
Modified();
@ -169,7 +170,7 @@ void ID::SetVal(zeek::IntrusivePtr<Val> v)
}
}
void ID::SetVal(zeek::IntrusivePtr<Val> v, InitClass c)
void ID::SetVal(ValPtr v, InitClass c)
{
if ( c == INIT_NONE || c == INIT_FULL )
{
@ -207,7 +208,7 @@ void ID::SetVal(zeek::IntrusivePtr<Val> v, InitClass c)
}
}
void ID::SetVal(zeek::IntrusivePtr<Expr> ev, InitClass c)
void ID::SetVal(ExprPtr ev, InitClass c)
{
const auto& a = attrs->Find(c == INIT_EXTRA ? ATTR_ADD_FUNC : ATTR_DEL_FUNC);
@ -222,7 +223,7 @@ bool ID::IsRedefinable() const
return GetAttr(ATTR_REDEF) != nullptr;
}
void ID::SetAttrs(zeek::IntrusivePtr<Attributes> a)
void ID::SetAttrs(AttributesPtr a)
{
attrs = nullptr;
AddAttrs(std::move(a));
@ -268,7 +269,7 @@ void ID::UpdateValAttrs()
}
}
const zeek::IntrusivePtr<Attr>& ID::GetAttr(AttrTag t) const
const AttrPtr& ID::GetAttr(AttrTag t) const
{
return attrs ? attrs->Find(t) : Attr::nil;
}
@ -278,12 +279,12 @@ bool ID::IsDeprecated() const
return GetAttr(ATTR_DEPRECATED) != nullptr;
}
void ID::MakeDeprecated(zeek::IntrusivePtr<Expr> deprecation)
void ID::MakeDeprecated(ExprPtr deprecation)
{
if ( IsDeprecated() )
return;
std::vector<zeek::IntrusivePtr<Attr>> attrv{zeek::make_intrusive<Attr>(ATTR_DEPRECATED, std::move(deprecation))};
std::vector<AttrPtr> attrv{zeek::make_intrusive<Attr>(ATTR_DEPRECATED, std::move(deprecation))};
AddAttrs(zeek::make_intrusive<Attributes>(std::move(attrv), GetType(), false, IsGlobal()));
}
@ -308,7 +309,7 @@ std::string ID::GetDeprecationWarning() const
return fmt("deprecated (%s): %s", Name(), result.c_str());
}
void ID::AddAttrs(zeek::IntrusivePtr<Attributes> a)
void ID::AddAttrs(AttributesPtr a)
{
if ( attrs )
attrs->AddAttrs(a);
@ -334,12 +335,12 @@ void ID::SetOption()
// option implied redefinable
if ( ! IsRedefinable() )
{
std::vector<zeek::IntrusivePtr<Attr>> attrv{zeek::make_intrusive<Attr>(ATTR_REDEF)};
std::vector<AttrPtr> attrv{zeek::make_intrusive<Attr>(ATTR_REDEF)};
AddAttrs(zeek::make_intrusive<Attributes>(std::move(attrv), GetType(), false, IsGlobal()));
}
}
void ID::EvalFunc(zeek::IntrusivePtr<Expr> ef, zeek::IntrusivePtr<Expr> ev)
void ID::EvalFunc(ExprPtr ef, ExprPtr ev)
{
auto arg1 = zeek::make_intrusive<zeek::detail::ConstExpr>(val);
auto args = zeek::make_intrusive<zeek::detail::ListExpr>();
@ -642,7 +643,7 @@ void ID::UpdateValID()
}
#endif
void ID::AddOptionHandler(zeek::IntrusivePtr<Func> callback, int priority)
void ID::AddOptionHandler(FuncPtr callback, int priority)
{
option_handlers.emplace(priority, std::move(callback));
}

83
src/ID.h
View file

@ -14,7 +14,10 @@
#include <vector>
class Val;
using ValPtr = zeek::IntrusivePtr<Val>;
class Func;
using FuncPtr = zeek::IntrusivePtr<Func>;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
@ -24,17 +27,27 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(TableType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(VectorType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek);
using TypePtr = zeek::IntrusivePtr<zeek::Type>;
using RecordTypePtr = zeek::IntrusivePtr<zeek::RecordType>;
using TableTypePtr = zeek::IntrusivePtr<zeek::TableType>;
using VectorTypePtr = zeek::IntrusivePtr<zeek::VectorType>;
using EnumTypePtr = zeek::IntrusivePtr<zeek::EnumType>;
namespace zeek::detail {
class Attributes;
class Expr;
using ExprPtr = zeek::IntrusivePtr<Expr>;
enum InitClass { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, };
enum IDScope { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL };
class ID;
using IDPtr = zeek::IntrusivePtr<ID>;
class ID final : public BroObj, public notifier::Modifiable {
public:
static inline const zeek::IntrusivePtr<ID> nil;
static inline const IDPtr nil;
ID(const char* name, IDScope arg_scope, bool arg_is_export);
@ -50,14 +63,14 @@ public:
std::string ModuleName() const;
void SetType(zeek::IntrusivePtr<Type> t);
void SetType(TypePtr t);
[[deprecated("Remove in v4.1. Use GetType().")]]
zeek::Type* Type() { return type.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]]
const zeek::Type* Type() const { return type.get(); }
const zeek::IntrusivePtr<zeek::Type>& GetType() const
const TypePtr& GetType() const
{ return type; }
template <class T>
@ -74,10 +87,10 @@ public:
void MakeType() { is_type = true; }
void SetVal(zeek::IntrusivePtr<Val> v);
void SetVal(ValPtr v);
void SetVal(zeek::IntrusivePtr<Val> v, InitClass c);
void SetVal(zeek::IntrusivePtr<Expr> ev, InitClass c);
void SetVal(ValPtr v, InitClass c);
void SetVal(ExprPtr ev, InitClass c);
bool HasVal() const { return val != nullptr; }
@ -86,7 +99,7 @@ public:
[[deprecated("Remove in v4.1. Use GetVal().")]]
const Val* ID_Val() const { return val.get(); }
const zeek::IntrusivePtr<Val>& GetVal() const
const ValPtr& GetVal() const
{ return val; }
void ClearVal();
@ -105,22 +118,22 @@ public:
bool IsRedefinable() const;
void SetAttrs(zeek::IntrusivePtr<Attributes> attr);
void AddAttrs(zeek::IntrusivePtr<Attributes> attr);
void RemoveAttr(zeek::detail::AttrTag a);
void SetAttrs(AttributesPtr attr);
void AddAttrs(AttributesPtr attr);
void RemoveAttr(AttrTag a);
void UpdateValAttrs();
const zeek::IntrusivePtr<Attributes>& GetAttrs() const
const AttributesPtr& GetAttrs() const
{ return attrs; }
[[deprecated("Remove in 4.1. Use GetAttrs().")]]
Attributes* Attrs() const { return attrs.get(); }
const zeek::IntrusivePtr<zeek::detail::Attr>& GetAttr(zeek::detail::AttrTag t) const;
const AttrPtr& GetAttr(zeek::detail::AttrTag t) const;
bool IsDeprecated() const;
void MakeDeprecated(zeek::IntrusivePtr<Expr> deprecation);
void MakeDeprecated(ExprPtr deprecation);
std::string GetDeprecationWarning() const;
@ -143,11 +156,11 @@ public:
bool HasOptionHandlers() const
{ return !option_handlers.empty(); }
void AddOptionHandler(zeek::IntrusivePtr<Func> callback, int priority);
void AddOptionHandler(FuncPtr callback, int priority);
std::vector<Func*> GetOptionHandlers() const;
protected:
void EvalFunc(zeek::IntrusivePtr<Expr> ef, zeek::IntrusivePtr<Expr> ev);
void EvalFunc(ExprPtr ef, ExprPtr ev);
#ifdef DEBUG
void UpdateValID();
@ -157,13 +170,13 @@ protected:
IDScope scope;
bool is_export;
bool infer_return_type;
zeek::IntrusivePtr<zeek::Type> type;
TypePtr type;
bool is_const, is_enum_const, is_type, is_option;
int offset;
zeek::IntrusivePtr<Val> val;
zeek::IntrusivePtr<Attributes> attrs;
ValPtr val;
AttributesPtr attrs;
// contains list of functions that are called when an option changes
std::multimap<int, zeek::IntrusivePtr<Func>> option_handlers;
std::multimap<int, FuncPtr> option_handlers;
};
@ -179,7 +192,7 @@ namespace zeek::id {
* @return The identifier, which may reference a nil object if no such
* name exists.
*/
const zeek::IntrusivePtr<zeek::detail::ID>& find(std::string_view name);
const detail::IDPtr& find(std::string_view name);
/**
* Lookup an ID by its name and return its type. A fatal occurs if the ID
@ -187,7 +200,7 @@ const zeek::IntrusivePtr<zeek::detail::ID>& find(std::string_view name);
* @param name The identifier name to lookup
* @return The type of the identifier.
*/
const zeek::IntrusivePtr<zeek::Type>& find_type(std::string_view name);
const TypePtr& find_type(std::string_view name);
/**
* Lookup an ID by its name and return its type (as cast to @c T).
@ -205,7 +218,7 @@ zeek::IntrusivePtr<T> find_type(std::string_view name)
* @param name The identifier name to lookup
* @return The current value of the identifier
*/
const zeek::IntrusivePtr<Val>& find_val(std::string_view name);
const ValPtr& find_val(std::string_view name);
/**
* Lookup an ID by its name and return its value (as cast to @c T).
@ -223,7 +236,7 @@ zeek::IntrusivePtr<T> find_val(std::string_view name)
* @param name The identifier name to lookup
* @return The current value of the identifier
*/
const zeek::IntrusivePtr<Val>& find_const(std::string_view name);
const ValPtr& find_const(std::string_view name);
/**
* Lookup an ID by its name and return its value (as cast to @c T).
@ -241,19 +254,19 @@ zeek::IntrusivePtr<T> find_const(std::string_view name)
* @param name The identifier name to lookup
* @return The current function value the identifier references.
*/
zeek::IntrusivePtr<Func> find_func(std::string_view name);
FuncPtr find_func(std::string_view name);
extern zeek::IntrusivePtr<zeek::RecordType> conn_id;
extern zeek::IntrusivePtr<zeek::RecordType> endpoint;
extern zeek::IntrusivePtr<zeek::RecordType> connection;
extern zeek::IntrusivePtr<zeek::RecordType> fa_file;
extern zeek::IntrusivePtr<zeek::RecordType> fa_metadata;
extern zeek::IntrusivePtr<zeek::EnumType> transport_proto;
extern zeek::IntrusivePtr<zeek::TableType> string_set;
extern zeek::IntrusivePtr<zeek::TableType> string_array;
extern zeek::IntrusivePtr<zeek::TableType> count_set;
extern zeek::IntrusivePtr<zeek::VectorType> string_vec;
extern zeek::IntrusivePtr<zeek::VectorType> index_vec;
extern RecordTypePtr conn_id;
extern RecordTypePtr endpoint;
extern RecordTypePtr connection;
extern RecordTypePtr fa_file;
extern RecordTypePtr fa_metadata;
extern EnumTypePtr transport_proto;
extern TableTypePtr string_set;
extern TableTypePtr string_array;
extern TableTypePtr count_set;
extern VectorTypePtr string_vec;
extern VectorTypePtr index_vec;
namespace detail {

18
src/IP.cc
View file

@ -13,7 +13,7 @@
#include "BroString.h"
#include "Reporter.h"
static zeek::IntrusivePtr<VectorVal> BuildOptionsVal(const u_char* data, int len)
static VectorValPtr BuildOptionsVal(const u_char* data, int len)
{
auto vv = zeek::make_intrusive<VectorVal>(zeek::id::find_type<zeek::VectorType>("ip6_options"));
@ -49,9 +49,9 @@ static zeek::IntrusivePtr<VectorVal> BuildOptionsVal(const u_char* data, int len
return vv;
}
zeek::IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(zeek::IntrusivePtr<VectorVal> chain) const
RecordValPtr IPv6_Hdr::ToVal(VectorValPtr chain) const
{
zeek::IntrusivePtr<RecordVal> rv;
RecordValPtr rv;
switch ( type ) {
case IPPROTO_IPV6:
@ -298,7 +298,7 @@ zeek::IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(zeek::IntrusivePtr<VectorVal> chai
return rv;
}
zeek::IntrusivePtr<RecordVal> IPv6_Hdr::ToVal() const
RecordValPtr IPv6_Hdr::ToVal() const
{ return ToVal(nullptr); }
RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const
@ -326,9 +326,9 @@ IPAddr IP_Hdr::DstAddr() const
return ip4 ? IPAddr(ip4->ip_dst) : ip6_hdrs->DstAddr();
}
zeek::IntrusivePtr<RecordVal> IP_Hdr::ToIPHdrVal() const
RecordValPtr IP_Hdr::ToIPHdrVal() const
{
zeek::IntrusivePtr<RecordVal> rval;
RecordValPtr rval;
if ( ip4 )
{
@ -356,7 +356,7 @@ RecordVal* IP_Hdr::BuildIPHdrVal() const
return ToIPHdrVal().release();
}
zeek::IntrusivePtr<RecordVal> IP_Hdr::ToPktHdrVal() const
RecordValPtr IP_Hdr::ToPktHdrVal() const
{
static auto pkt_hdr_type = zeek::id::find_type<zeek::RecordType>("pkt_hdr");
return ToPktHdrVal(zeek::make_intrusive<RecordVal>(pkt_hdr_type), 0);
@ -367,7 +367,7 @@ RecordVal* IP_Hdr::BuildPktHdrVal() const
return ToPktHdrVal().release();
}
zeek::IntrusivePtr<RecordVal> IP_Hdr::ToPktHdrVal(zeek::IntrusivePtr<RecordVal> pkt_hdr, int sindex) const
RecordValPtr IP_Hdr::ToPktHdrVal(RecordValPtr pkt_hdr, int sindex) const
{
static auto tcp_hdr_type = zeek::id::find_type<zeek::RecordType>("tcp_hdr");
static auto udp_hdr_type = zeek::id::find_type<zeek::RecordType>("udp_hdr");
@ -676,7 +676,7 @@ void IPv6_Hdr_Chain::ProcessDstOpts(const struct ip6_dest* d, uint16_t len)
}
#endif
zeek::IntrusivePtr<VectorVal> IPv6_Hdr_Chain::ToVal() const
VectorValPtr IPv6_Hdr_Chain::ToVal() const
{
static auto ip6_ext_hdr_type = zeek::id::find_type<zeek::RecordType>("ip6_ext_hdr");
static auto ip6_hopopts_type = zeek::id::find_type<zeek::RecordType>("ip6_hopopts");

15
src/IP.h
View file

@ -20,6 +20,9 @@ class IPAddr;
class RecordVal;
class VectorVal;
using RecordValPtr = zeek::IntrusivePtr<RecordVal>;
using VectorValPtr = zeek::IntrusivePtr<VectorVal>;
#ifdef ENABLE_MOBILE_IPV6
#ifndef IPPROTO_MOBILITY
@ -136,8 +139,8 @@ public:
/**
* Returns the script-layer record representation of the header.
*/
zeek::IntrusivePtr<RecordVal> ToVal(zeek::IntrusivePtr<VectorVal> chain) const;
zeek::IntrusivePtr<RecordVal> ToVal() const;
RecordValPtr ToVal(VectorValPtr chain) const;
RecordValPtr ToVal() const;
[[deprecated("Remove in v4.1. Use ToVal() instead.")]]
RecordVal* BuildRecordVal(VectorVal* chain = nullptr) const;
@ -229,7 +232,7 @@ public:
* Returns a vector of ip6_ext_hdr RecordVals that includes script-layer
* representation of all extension headers in the chain.
*/
zeek::IntrusivePtr<VectorVal> ToVal() const;
VectorValPtr ToVal() const;
[[deprecated("Remove in v4.1. Use ToVal() instead.")]]
VectorVal* BuildVal() const;
@ -526,7 +529,7 @@ public:
/**
* Returns an ip_hdr or ip6_hdr_chain RecordVal.
*/
zeek::IntrusivePtr<RecordVal> ToIPHdrVal() const;
RecordValPtr ToIPHdrVal() const;
[[deprecated("Remove in v4.1. Use ToIPHdrVal() instead.")]]
RecordVal* BuildIPHdrVal() const;
@ -535,7 +538,7 @@ public:
* Returns a pkt_hdr RecordVal, which includes not only the IP header, but
* also upper-layer (tcp/udp/icmp) headers.
*/
zeek::IntrusivePtr<RecordVal> ToPktHdrVal() const;
RecordValPtr ToPktHdrVal() const;
[[deprecated("Remove in v4.1. Use ToPktHdrVal() instead.")]]
RecordVal* BuildPktHdrVal() const;
@ -544,7 +547,7 @@ public:
* Same as above, but simply add our values into the record at the
* specified starting index.
*/
zeek::IntrusivePtr<RecordVal> ToPktHdrVal(zeek::IntrusivePtr<RecordVal> pkt_hdr, int sindex) const;
RecordValPtr ToPktHdrVal(RecordValPtr pkt_hdr, int sindex) const;
[[deprecated("Remove in v4.1. Use ToPktHdrVal() instead.")]]
RecordVal* BuildPktHdrVal(RecordVal* pkt_hdr, int sindex) const;

48
src/OpaqueVal.cc
View file

@ -40,7 +40,7 @@ OpaqueMgr* OpaqueMgr::mgr()
OpaqueVal::OpaqueVal(zeek::OpaqueType* t) : OpaqueVal({zeek::NewRef{}, t})
{}
OpaqueVal::OpaqueVal(zeek::IntrusivePtr<zeek::OpaqueType> t) : Val(std::move(t))
OpaqueVal::OpaqueVal(zeek::OpaqueTypePtr t) : Val(std::move(t))
{}
OpaqueVal::~OpaqueVal()
@ -58,7 +58,7 @@ const std::string& OpaqueMgr::TypeID(const OpaqueVal* v) const
return x->first;
}
zeek::IntrusivePtr<OpaqueVal> OpaqueMgr::Instantiate(const std::string& id) const
OpaqueValPtr OpaqueMgr::Instantiate(const std::string& id) const
{
auto x = _types.find(id);
return x != _types.end() ? (*x->second)() : nullptr;
@ -75,7 +75,7 @@ broker::expected<broker::data> OpaqueVal::Serialize() const
return {broker::vector{std::move(type), std::move(*d)}};
}
zeek::IntrusivePtr<OpaqueVal> OpaqueVal::Unserialize(const broker::data& data)
OpaqueValPtr OpaqueVal::Unserialize(const broker::data& data)
{
auto v = caf::get_if<broker::vector>(&data);
@ -96,7 +96,7 @@ zeek::IntrusivePtr<OpaqueVal> OpaqueVal::Unserialize(const broker::data& data)
return val;
}
broker::expected<broker::data> OpaqueVal::SerializeType(const zeek::IntrusivePtr<zeek::Type>& t)
broker::expected<broker::data> OpaqueVal::SerializeType(const zeek::TypePtr& t)
{
if ( t->InternalType() == zeek::TYPE_INTERNAL_ERROR )
return broker::ec::invalid_data;
@ -112,7 +112,7 @@ broker::expected<broker::data> OpaqueVal::SerializeType(const zeek::IntrusivePtr
return {broker::vector{false, static_cast<uint64_t>(t->Tag())}};
}
zeek::IntrusivePtr<zeek::Type> OpaqueVal::UnserializeType(const broker::data& data)
zeek::TypePtr OpaqueVal::UnserializeType(const broker::data& data)
{
auto v = caf::get_if<broker::vector>(&data);
if ( ! (v && v->size() == 2) )
@ -145,7 +145,7 @@ zeek::IntrusivePtr<zeek::Type> OpaqueVal::UnserializeType(const broker::data& da
return zeek::base_type(static_cast<zeek::TypeTag>(*tag));
}
zeek::IntrusivePtr<Val> OpaqueVal::DoClone(CloneState* state)
ValPtr OpaqueVal::DoClone(CloneState* state)
{
auto d = OpaqueVal::Serialize();
if ( ! d )
@ -169,7 +169,7 @@ bool HashVal::Init()
return valid;
}
zeek::IntrusivePtr<StringVal> HashVal::Get()
StringValPtr HashVal::Get()
{
if ( ! valid )
return val_mgr->EmptyString();
@ -200,13 +200,13 @@ bool HashVal::DoFeed(const void*, size_t)
return false;
}
zeek::IntrusivePtr<StringVal> HashVal::DoGet()
StringValPtr HashVal::DoGet()
{
assert(! "missing implementation of DoGet()");
return val_mgr->EmptyString();
}
HashVal::HashVal(zeek::IntrusivePtr<zeek::OpaqueType> t) : OpaqueVal(std::move(t))
HashVal::HashVal(zeek::OpaqueTypePtr t) : OpaqueVal(std::move(t))
{
valid = false;
}
@ -239,12 +239,12 @@ void HashVal::digest_one(EVP_MD_CTX* h, const Val* v)
}
}
void HashVal::digest_one(EVP_MD_CTX* h, const zeek::IntrusivePtr<Val>& v)
void HashVal::digest_one(EVP_MD_CTX* h, const ValPtr& v)
{
digest_one(h, v.get());
}
zeek::IntrusivePtr<Val> MD5Val::DoClone(CloneState* state)
ValPtr MD5Val::DoClone(CloneState* state)
{
auto out = zeek::make_intrusive<MD5Val>();
@ -275,7 +275,7 @@ bool MD5Val::DoFeed(const void* data, size_t size)
return true;
}
zeek::IntrusivePtr<StringVal> MD5Val::DoGet()
StringValPtr MD5Val::DoGet()
{
if ( ! IsValid() )
return val_mgr->EmptyString();
@ -364,7 +364,7 @@ SHA1Val::~SHA1Val()
EVP_MD_CTX_free(ctx);
}
zeek::IntrusivePtr<Val> SHA1Val::DoClone(CloneState* state)
ValPtr SHA1Val::DoClone(CloneState* state)
{
auto out = zeek::make_intrusive<SHA1Val>();
@ -395,7 +395,7 @@ bool SHA1Val::DoFeed(const void* data, size_t size)
return true;
}
zeek::IntrusivePtr<StringVal> SHA1Val::DoGet()
StringValPtr SHA1Val::DoGet()
{
if ( ! IsValid() )
return val_mgr->EmptyString();
@ -487,7 +487,7 @@ SHA256Val::~SHA256Val()
EVP_MD_CTX_free(ctx);
}
zeek::IntrusivePtr<Val> SHA256Val::DoClone(CloneState* state)
ValPtr SHA256Val::DoClone(CloneState* state)
{
auto out = zeek::make_intrusive<SHA256Val>();
@ -518,7 +518,7 @@ bool SHA256Val::DoFeed(const void* data, size_t size)
return true;
}
zeek::IntrusivePtr<StringVal> SHA256Val::DoGet()
StringValPtr SHA256Val::DoGet()
{
if ( ! IsValid() )
return val_mgr->EmptyString();
@ -711,7 +711,7 @@ BloomFilterVal::BloomFilterVal(probabilistic::BloomFilter* bf)
bloom_filter = bf;
}
zeek::IntrusivePtr<Val> BloomFilterVal::DoClone(CloneState* state)
ValPtr BloomFilterVal::DoClone(CloneState* state)
{
if ( bloom_filter )
{
@ -723,7 +723,7 @@ zeek::IntrusivePtr<Val> BloomFilterVal::DoClone(CloneState* state)
return state->NewClone(this, zeek::make_intrusive<BloomFilterVal>());
}
bool BloomFilterVal::Typify(zeek::IntrusivePtr<zeek::Type> arg_type)
bool BloomFilterVal::Typify(zeek::TypePtr arg_type)
{
if ( type )
return false;
@ -765,8 +765,8 @@ std::string BloomFilterVal::InternalState() const
return bloom_filter->InternalState();
}
zeek::IntrusivePtr<BloomFilterVal> BloomFilterVal::Merge(const BloomFilterVal* x,
const BloomFilterVal* y)
BloomFilterValPtr BloomFilterVal::Merge(const BloomFilterVal* x,
const BloomFilterVal* y)
{
if ( x->Type() && // any one 0 is ok here
y->Type() &&
@ -876,13 +876,13 @@ CardinalityVal::~CardinalityVal()
delete hash;
}
zeek::IntrusivePtr<Val> CardinalityVal::DoClone(CloneState* state)
ValPtr CardinalityVal::DoClone(CloneState* state)
{
return state->NewClone(this,
zeek::make_intrusive<CardinalityVal>(new probabilistic::CardinalityCounter(*c)));
}
bool CardinalityVal::Typify(zeek::IntrusivePtr<zeek::Type> arg_type)
bool CardinalityVal::Typify(zeek::TypePtr arg_type)
{
if ( type )
return false;
@ -957,7 +957,7 @@ ParaglobVal::ParaglobVal(std::unique_ptr<paraglob::Paraglob> p)
this->internal_paraglob = std::move(p);
}
zeek::IntrusivePtr<VectorVal> ParaglobVal::Get(StringVal* &pattern)
VectorValPtr ParaglobVal::Get(StringVal* &pattern)
{
auto rval = zeek::make_intrusive<VectorVal>(zeek::id::string_vec);
std::string string_pattern (reinterpret_cast<const char*>(pattern->Bytes()), pattern->Len());
@ -1018,7 +1018,7 @@ bool ParaglobVal::DoUnserialize(const broker::data& data)
return true;
}
zeek::IntrusivePtr<Val> ParaglobVal::DoClone(CloneState* state)
ValPtr ParaglobVal::DoClone(CloneState* state)
{
try {
return zeek::make_intrusive<ParaglobVal>

65
src/OpaqueVal.h
View file

@ -13,7 +13,12 @@
#include <sys/types.h> // for u_char
namespace broker { class data; }
class OpaqueVal;
using OpaqueValPtr = zeek::IntrusivePtr<OpaqueVal>;
class BloomFilterVal;
using BloomFilterValPtr = zeek::IntrusivePtr<BloomFilterVal>;
/**
* Singleton that registers all available all available types of opaque
@ -21,7 +26,7 @@ class OpaqueVal;
*/
class OpaqueMgr {
public:
using Factory = zeek::IntrusivePtr<OpaqueVal> ();
using Factory = OpaqueValPtr ();
/**
* Return's a unique ID for the type of an opaque value.
@ -45,7 +50,7 @@ public:
* is unknown, this will return null.
*
*/
zeek::IntrusivePtr<OpaqueVal> Instantiate(const std::string& id) const;
OpaqueValPtr Instantiate(const std::string& id) const;
/** Returns the global manager singleton object. */
static OpaqueMgr* mgr();
@ -72,7 +77,7 @@ private:
broker::expected<broker::data> DoSerialize() const override; \
bool DoUnserialize(const broker::data& data) override; \
const char* OpaqueName() const override { return #T; } \
static zeek::IntrusivePtr<OpaqueVal> OpaqueInstantiate() { return zeek::make_intrusive<T>(); }
static OpaqueValPtr OpaqueInstantiate() { return zeek::make_intrusive<T>(); }
#define __OPAQUE_MERGE(a, b) a ## b
#define __OPAQUE_ID(x) __OPAQUE_MERGE(_opaque, x)
@ -89,7 +94,7 @@ class OpaqueVal : public Val {
public:
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit OpaqueVal(zeek::OpaqueType* t);
explicit OpaqueVal(zeek::IntrusivePtr<zeek::OpaqueType> t);
explicit OpaqueVal(zeek::OpaqueTypePtr t);
~OpaqueVal() override;
/**
@ -106,7 +111,7 @@ public:
* @param data Broker representation as returned by *Serialize()*.
* @return unserialized instances with reference count at +1
*/
static zeek::IntrusivePtr<OpaqueVal> Unserialize(const broker::data& data);
static OpaqueValPtr Unserialize(const broker::data& data);
protected:
friend class Val;
@ -142,19 +147,19 @@ protected:
* may also override this with a more efficient custom clone
* implementation of their own.
*/
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
/**
* Helper function for derived class that need to record a type
* during serialization.
*/
static broker::expected<broker::data> SerializeType(const zeek::IntrusivePtr<zeek::Type>& t);
static broker::expected<broker::data> SerializeType(const zeek::TypePtr& t);
/**
* Helper function for derived class that need to restore a type
* during unserialization. Returns the type at reference count +1.
*/
static zeek::IntrusivePtr<zeek::Type> UnserializeType(const broker::data& data);
static zeek::TypePtr UnserializeType(const broker::data& data);
};
namespace probabilistic {
@ -178,21 +183,21 @@ public:
bool IsValid() const;
bool Init();
bool Feed(const void* data, size_t size);
zeek::IntrusivePtr<StringVal> Get();
StringValPtr Get();
protected:
static void digest_one(EVP_MD_CTX* h, const Val* v);
static void digest_one(EVP_MD_CTX* h, const zeek::IntrusivePtr<Val>& v);
static void digest_one(EVP_MD_CTX* h, const ValPtr& v);
HashVal() { valid = false; }
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit HashVal(zeek::OpaqueType* t);
explicit HashVal(zeek::IntrusivePtr<zeek::OpaqueType> t);
explicit HashVal(zeek::OpaqueTypePtr t);
virtual bool DoInit();
virtual bool DoFeed(const void* data, size_t size);
virtual zeek::IntrusivePtr<StringVal> DoGet();
virtual StringValPtr DoGet();
private:
// This flag exists because Get() can only be called once.
@ -221,14 +226,14 @@ public:
MD5Val();
~MD5Val();
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
protected:
friend class Val;
bool DoInit() override;
bool DoFeed(const void* data, size_t size) override;
zeek::IntrusivePtr<StringVal> DoGet() override;
StringValPtr DoGet() override;
DECLARE_OPAQUE_VALUE(MD5Val)
private:
@ -244,14 +249,14 @@ public:
SHA1Val();
~SHA1Val();
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
protected:
friend class Val;
bool DoInit() override;
bool DoFeed(const void* data, size_t size) override;
zeek::IntrusivePtr<StringVal> DoGet() override;
StringValPtr DoGet() override;
DECLARE_OPAQUE_VALUE(SHA1Val)
private:
@ -267,14 +272,14 @@ public:
SHA256Val();
~SHA256Val();
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
protected:
friend class Val;
bool DoInit() override;
bool DoFeed(const void* data, size_t size) override;
zeek::IntrusivePtr<StringVal> DoGet() override;
StringValPtr DoGet() override;
DECLARE_OPAQUE_VALUE(SHA256Val)
private:
@ -302,12 +307,12 @@ public:
explicit BloomFilterVal(probabilistic::BloomFilter* bf);
~BloomFilterVal() override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
const zeek::IntrusivePtr<zeek::Type>& Type() const
const zeek::TypePtr& Type() const
{ return type; }
bool Typify(zeek::IntrusivePtr<zeek::Type> type);
bool Typify(zeek::TypePtr type);
void Add(const Val* val);
size_t Count(const Val* val) const;
@ -315,8 +320,8 @@ public:
bool Empty() const;
std::string InternalState() const;
static zeek::IntrusivePtr<BloomFilterVal> Merge(const BloomFilterVal* x,
const BloomFilterVal* y);
static BloomFilterValPtr Merge(const BloomFilterVal* x,
const BloomFilterVal* y);
protected:
friend class Val;
@ -328,7 +333,7 @@ private:
BloomFilterVal(const BloomFilterVal&);
BloomFilterVal& operator=(const BloomFilterVal&);
zeek::IntrusivePtr<zeek::Type> type;
zeek::TypePtr type;
CompositeHash* hash;
probabilistic::BloomFilter* bloom_filter;
};
@ -339,14 +344,14 @@ public:
explicit CardinalityVal(probabilistic::CardinalityCounter*);
~CardinalityVal() override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
void Add(const Val* val);
const zeek::IntrusivePtr<zeek::Type>& Type() const
const zeek::TypePtr& Type() const
{ return type; }
bool Typify(zeek::IntrusivePtr<zeek::Type> type);
bool Typify(zeek::TypePtr type);
probabilistic::CardinalityCounter* Get() { return c; };
@ -355,7 +360,7 @@ protected:
DECLARE_OPAQUE_VALUE(CardinalityVal)
private:
zeek::IntrusivePtr<zeek::Type> type;
zeek::TypePtr type;
CompositeHash* hash;
probabilistic::CardinalityCounter* c;
};
@ -363,8 +368,8 @@ private:
class ParaglobVal : public OpaqueVal {
public:
explicit ParaglobVal(std::unique_ptr<paraglob::Paraglob> p);
zeek::IntrusivePtr<VectorVal> Get(StringVal* &pattern);
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
VectorValPtr Get(StringVal* &pattern);
ValPtr DoClone(CloneState* state) override;
bool operator==(const ParaglobVal& other) const;
protected:

2
src/Reporter.cc
View file

@ -417,7 +417,7 @@ void Reporter::Weird(Connection* conn, const char* name, const char* addl)
"%s", name);
}
void Reporter::Weird(zeek::IntrusivePtr<RecordVal> conn_id, zeek::IntrusivePtr<StringVal> uid,
void Reporter::Weird(RecordValPtr conn_id, StringValPtr uid,
const char* name, const char* addl)
{
UpdateWeirdStats(name);

5
src/Reporter.h
View file

@ -28,6 +28,9 @@ namespace zeek {
template <class T> class IntrusivePtr;
}
using RecordValPtr = zeek::IntrusivePtr<RecordVal>;
using StringValPtr = zeek::IntrusivePtr<StringVal>;
// One cannot raise this exception directly, go through the
// Reporter's methods instead.
@ -99,7 +102,7 @@ public:
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::IntrusivePtr<RecordVal> conn_id, zeek::IntrusivePtr<StringVal> uid,
void Weird(RecordValPtr conn_id, StringValPtr uid,
const char* name, const char* addl = ""); // Raises expired_conn_weird().
void Weird(const IPAddr& orig, const IPAddr& resp, const char* name, const char* addl = ""); // Raises flow_weird().

22
src/Scope.cc
View file

@ -15,8 +15,8 @@ typedef PList<Scope> scope_list;
static scope_list scopes;
static Scope* top_scope;
Scope::Scope(zeek::IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> al)
Scope::Scope(zeek::detail::IDPtr id,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> al)
: scope_id(std::move(id)), attrs(std::move(al))
{
return_type = nullptr;
@ -35,7 +35,7 @@ Scope::Scope(zeek::IntrusivePtr<zeek::detail::ID> id,
}
}
const zeek::IntrusivePtr<zeek::detail::ID>& Scope::Find(std::string_view name) const
const zeek::detail::IDPtr& Scope::Find(std::string_view name) const
{
auto entry = local.find(name);
@ -45,7 +45,7 @@ const zeek::IntrusivePtr<zeek::detail::ID>& Scope::Find(std::string_view name) c
return zeek::detail::ID::nil;
}
zeek::IntrusivePtr<zeek::detail::ID> Scope::Remove(std::string_view name)
zeek::detail::IDPtr Scope::Remove(std::string_view name)
{
auto entry = local.find(name);
@ -59,12 +59,12 @@ zeek::IntrusivePtr<zeek::detail::ID> Scope::Remove(std::string_view name)
return nullptr;
}
zeek::IntrusivePtr<zeek::detail::ID> Scope::GenerateTemporary(const char* name)
zeek::detail::IDPtr Scope::GenerateTemporary(const char* name)
{
return zeek::make_intrusive<zeek::detail::ID>(name, zeek::detail::SCOPE_FUNCTION, false);
}
std::vector<zeek::IntrusivePtr<zeek::detail::ID>> Scope::GetInits()
std::vector<zeek::detail::IDPtr> Scope::GetInits()
{
auto rval = std::move(inits);
inits = {};
@ -119,7 +119,7 @@ TraversalCode Scope::Traverse(TraversalCallback* cb) const
}
const zeek::IntrusivePtr<zeek::detail::ID>& lookup_ID(
const zeek::detail::IDPtr& lookup_ID(
const char* name, const char* curr_module,
bool no_global, bool same_module_only,
bool check_export)
@ -154,7 +154,7 @@ const zeek::IntrusivePtr<zeek::detail::ID>& lookup_ID(
return zeek::detail::ID::nil;
}
zeek::IntrusivePtr<zeek::detail::ID> install_ID(
zeek::detail::IDPtr install_ID(
const char* name, const char* module_name,
bool is_global, bool is_export)
{
@ -191,14 +191,14 @@ void push_existing_scope(Scope* scope)
scopes.push_back(scope);
}
void push_scope(zeek::IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attrs)
void push_scope(zeek::detail::IDPtr id,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs)
{
top_scope = new Scope(std::move(id), std::move(attrs));
scopes.push_back(top_scope);
}
zeek::IntrusivePtr<Scope> pop_scope()
ScopePtr pop_scope()
{
if ( scopes.empty() )
reporter->InternalError("scope underflow");

55
src/Scope.h
View file

@ -13,18 +13,29 @@
#include "TraverseTypes.h"
template <class T> class IntrusivePtr;
class ListVal;
namespace zeek { class Type; }
namespace zeek {
class Type;
using TypePtr = zeek::IntrusivePtr<zeek::Type>;
}
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
namespace zeek::detail {
class Attr;
using AttrPtr = zeek::IntrusivePtr<Attr>;
using IDPtr = zeek::IntrusivePtr<ID>;
}
class Scope;
using ScopePtr = zeek::IntrusivePtr<Scope>;
class Scope : public BroObj {
public:
explicit Scope(zeek::IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> al);
explicit Scope(zeek::detail::IDPtr id,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> al);
const zeek::IntrusivePtr<zeek::detail::ID>& Find(std::string_view name) const;
const zeek::detail::IDPtr& Find(std::string_view name) const;
template<typename N>
[[deprecated("Remove in v4.1. Use Find().")]]
@ -34,34 +45,34 @@ public:
template<typename N, typename I>
void Insert(N&& name, I&& id) { local[std::forward<N>(name)] = std::forward<I>(id); }
zeek::IntrusivePtr<zeek::detail::ID> Remove(std::string_view name);
zeek::detail::IDPtr Remove(std::string_view name);
[[deprecated("Remove in v4.1. Use GetID().")]]
zeek::detail::ID* ScopeID() const { return scope_id.get(); }
const zeek::IntrusivePtr<zeek::detail::ID>& GetID() const
const zeek::detail::IDPtr& GetID() const
{ return scope_id; }
const std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>>& Attrs() const
const std::unique_ptr<std::vector<zeek::detail::AttrPtr>>& Attrs() const
{ return attrs; }
[[deprecated("Remove in v4.1. Use GetReturnTrype().")]]
zeek::Type* ReturnType() const { return return_type.get(); }
const zeek::IntrusivePtr<zeek::Type>& GetReturnType() const
const zeek::TypePtr& GetReturnType() const
{ return return_type; }
size_t Length() const { return local.size(); }
const auto& Vars() { return local; }
zeek::IntrusivePtr<zeek::detail::ID> GenerateTemporary(const char* name);
zeek::detail::IDPtr GenerateTemporary(const char* name);
// Returns the list of variables needing initialization, and
// removes it from this Scope.
std::vector<zeek::IntrusivePtr<zeek::detail::ID>> GetInits();
std::vector<zeek::detail::IDPtr> GetInits();
// Adds a variable to the list.
void AddInit(zeek::IntrusivePtr<zeek::detail::ID> id)
void AddInit(zeek::detail::IDPtr id)
{ inits.emplace_back(std::move(id)); }
void Describe(ODesc* d) const override;
@ -69,33 +80,33 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const;
protected:
zeek::IntrusivePtr<zeek::detail::ID> scope_id;
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attrs;
zeek::IntrusivePtr<zeek::Type> return_type;
std::map<std::string, zeek::IntrusivePtr<zeek::detail::ID>, std::less<>> local;
std::vector<zeek::IntrusivePtr<zeek::detail::ID>> inits;
zeek::detail::IDPtr scope_id;
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs;
zeek::TypePtr return_type;
std::map<std::string, zeek::detail::IDPtr, std::less<>> local;
std::vector<zeek::detail::IDPtr> inits;
};
extern bool in_debug;
// If no_global is true, don't search in the default "global" namespace.
extern const zeek::IntrusivePtr<zeek::detail::ID>& lookup_ID(
extern const zeek::detail::IDPtr& lookup_ID(
const char* name, const char* module,
bool no_global = false,
bool same_module_only = false,
bool check_export = true);
extern zeek::IntrusivePtr<zeek::detail::ID> install_ID(
extern zeek::detail::IDPtr install_ID(
const char* name, const char* module_name,
bool is_global, bool is_export);
extern void push_scope(zeek::IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attrs);
extern void push_scope(zeek::detail::IDPtr id,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs);
extern void push_existing_scope(Scope* scope);
// Returns the one popped off.
extern zeek::IntrusivePtr<Scope> pop_scope();
extern ScopePtr pop_scope();
extern Scope* current_scope();
extern Scope* global_scope();

2
src/Sessions.cc
View file

@ -703,7 +703,7 @@ void NetSessions::DoNextPacket(double t, const Packet* pkt, const IP_Hdr* ip_hdr
conn->CheckFlowLabel(is_orig, ip_hdr->FlowLabel());
zeek::IntrusivePtr<Val> pkt_hdr_val;
ValPtr pkt_hdr_val;
if ( ipv6_ext_headers && ip_hdr->NumHeaders() > 1 )
{

96
src/Stmt.cc
View file

@ -133,7 +133,7 @@ void Stmt::AccessStats(ODesc* d) const
}
}
ExprListStmt::ExprListStmt(BroStmtTag t, zeek::IntrusivePtr<ListExpr> arg_l)
ExprListStmt::ExprListStmt(BroStmtTag t, ListExprPtr arg_l)
: Stmt(t), l(std::move(arg_l))
{
const expr_list& e = l->Exprs();
@ -149,7 +149,7 @@ ExprListStmt::ExprListStmt(BroStmtTag t, zeek::IntrusivePtr<ListExpr> arg_l)
ExprListStmt::~ExprListStmt() = default;
zeek::IntrusivePtr<Val> ExprListStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr ExprListStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
last_access = network_time;
flow = FLOW_NEXT;
@ -187,7 +187,7 @@ TraversalCode ExprListStmt::Traverse(TraversalCallback* cb) const
static BroFile* print_stdout = nullptr;
static zeek::IntrusivePtr<EnumVal> lookup_enum_val(const char* module_name, const char* name)
static EnumValPtr lookup_enum_val(const char* module_name, const char* name)
{
const auto& id = lookup_ID(name, module_name);
assert(id);
@ -201,7 +201,7 @@ static zeek::IntrusivePtr<EnumVal> lookup_enum_val(const char* module_name, cons
return et->GetVal(index);
}
static void print_log(const std::vector<zeek::IntrusivePtr<Val>>& vals)
static void print_log(const std::vector<ValPtr>& vals)
{
static auto plval = lookup_enum_val("Log", "PRINTLOG");
static auto lpli = zeek::id::find_type<RecordType>("Log::PrintLogInfo");
@ -220,8 +220,8 @@ static void print_log(const std::vector<zeek::IntrusivePtr<Val>>& vals)
log_mgr->Write(plval.get(), record.get());
}
zeek::IntrusivePtr<Val> PrintStmt::DoExec(std::vector<zeek::IntrusivePtr<Val>> vals,
stmt_flow_type& /* flow */) const
ValPtr PrintStmt::DoExec(std::vector<ValPtr> vals,
stmt_flow_type& /* flow */) const
{
RegisterAccess();
@ -290,7 +290,7 @@ zeek::IntrusivePtr<Val> PrintStmt::DoExec(std::vector<zeek::IntrusivePtr<Val>> v
return nullptr;
}
ExprStmt::ExprStmt(zeek::IntrusivePtr<Expr> arg_e) : Stmt(STMT_EXPR), e(std::move(arg_e))
ExprStmt::ExprStmt(ExprPtr arg_e) : Stmt(STMT_EXPR), e(std::move(arg_e))
{
if ( e && e->IsPure() )
Warn("expression value ignored");
@ -298,7 +298,7 @@ ExprStmt::ExprStmt(zeek::IntrusivePtr<Expr> arg_e) : Stmt(STMT_EXPR), e(std::mov
SetLocationInfo(e->GetLocationInfo());
}
ExprStmt::ExprStmt(BroStmtTag t, zeek::IntrusivePtr<Expr> arg_e) : Stmt(t), e(std::move(arg_e))
ExprStmt::ExprStmt(BroStmtTag t, ExprPtr arg_e) : Stmt(t), e(std::move(arg_e))
{
if ( e )
SetLocationInfo(e->GetLocationInfo());
@ -306,7 +306,7 @@ ExprStmt::ExprStmt(BroStmtTag t, zeek::IntrusivePtr<Expr> arg_e) : Stmt(t), e(st
ExprStmt::~ExprStmt() = default;
zeek::IntrusivePtr<Val> ExprStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr ExprStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -319,7 +319,7 @@ zeek::IntrusivePtr<Val> ExprStmt::Exec(Frame* f, stmt_flow_type& flow) const
return nullptr;
}
zeek::IntrusivePtr<Val> ExprStmt::DoExec(Frame* /* f */, Val* /* v */, stmt_flow_type& /* flow */) const
ValPtr ExprStmt::DoExec(Frame* /* f */, Val* /* v */, stmt_flow_type& /* flow */) const
{
return nullptr;
}
@ -365,9 +365,9 @@ TraversalCode ExprStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
IfStmt::IfStmt(zeek::IntrusivePtr<Expr> test,
zeek::IntrusivePtr<Stmt> arg_s1,
zeek::IntrusivePtr<Stmt> arg_s2)
IfStmt::IfStmt(ExprPtr test,
StmtPtr arg_s1,
StmtPtr arg_s2)
: ExprStmt(STMT_IF, std::move(test)),
s1(std::move(arg_s1)), s2(std::move(arg_s2))
{
@ -381,7 +381,7 @@ IfStmt::IfStmt(zeek::IntrusivePtr<Expr> test,
IfStmt::~IfStmt() = default;
zeek::IntrusivePtr<Val> IfStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
ValPtr IfStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
{
// Treat 0 as false, but don't require 1 for true.
Stmt* do_stmt = v->IsZero() ? s2.get() : s1.get();
@ -466,8 +466,8 @@ static BroStmtTag get_last_stmt_tag(const Stmt* stmt)
return get_last_stmt_tag(stmts->Stmts()[len - 1]);
}
Case::Case(zeek::IntrusivePtr<ListExpr> arg_expr_cases, id_list* arg_type_cases,
zeek::IntrusivePtr<Stmt> arg_s)
Case::Case(ListExprPtr arg_expr_cases, id_list* arg_type_cases,
StmtPtr arg_s)
: expr_cases(std::move(arg_expr_cases)), type_cases(arg_type_cases),
s(std::move(arg_s))
{
@ -591,7 +591,7 @@ void SwitchStmt::Init()
case_label_value_map.SetDeleteFunc(int_del_func);
}
SwitchStmt::SwitchStmt(zeek::IntrusivePtr<Expr> index, case_list* arg_cases)
SwitchStmt::SwitchStmt(ExprPtr index, case_list* arg_cases)
: ExprStmt(STMT_SWITCH, std::move(index)),
cases(arg_cases), default_case_idx(-1)
{
@ -797,9 +797,9 @@ std::pair<int, ID*> SwitchStmt::FindCaseLabelMatch(const Val* v) const
return std::make_pair(label_idx, label_id);
}
zeek::IntrusivePtr<Val> SwitchStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
ValPtr SwitchStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
{
zeek::IntrusivePtr<Val> rval;
ValPtr rval;
auto m = FindCaseLabelMatch(v);
int matching_label_idx = m.first;
@ -882,7 +882,7 @@ TraversalCode SwitchStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
AddStmt::AddStmt(zeek::IntrusivePtr<Expr> arg_e) : ExprStmt(STMT_ADD, std::move(arg_e))
AddStmt::AddStmt(ExprPtr arg_e) : ExprStmt(STMT_ADD, std::move(arg_e))
{
if ( ! e->CanAdd() )
Error("illegal add statement");
@ -893,7 +893,7 @@ bool AddStmt::IsPure() const
return false;
}
zeek::IntrusivePtr<Val> AddStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr AddStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -915,7 +915,7 @@ TraversalCode AddStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
DelStmt::DelStmt(zeek::IntrusivePtr<Expr> arg_e) : ExprStmt(STMT_DELETE, std::move(arg_e))
DelStmt::DelStmt(ExprPtr arg_e) : ExprStmt(STMT_DELETE, std::move(arg_e))
{
if ( e->IsError() )
return;
@ -929,7 +929,7 @@ bool DelStmt::IsPure() const
return false;
}
zeek::IntrusivePtr<Val> DelStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr DelStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -950,12 +950,12 @@ TraversalCode DelStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
EventStmt::EventStmt(zeek::IntrusivePtr<EventExpr> arg_e)
EventStmt::EventStmt(EventExprPtr arg_e)
: ExprStmt(STMT_EVENT, arg_e), event_expr(std::move(arg_e))
{
}
zeek::IntrusivePtr<Val> EventStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr EventStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
auto args = eval_list(f, event_expr->Args());
@ -981,8 +981,8 @@ TraversalCode EventStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
WhileStmt::WhileStmt(zeek::IntrusivePtr<Expr> arg_loop_condition,
zeek::IntrusivePtr<Stmt> arg_body)
WhileStmt::WhileStmt(ExprPtr arg_loop_condition,
StmtPtr arg_body)
: loop_condition(std::move(arg_loop_condition)), body(std::move(arg_body))
{
if ( ! loop_condition->IsError() &&
@ -1031,11 +1031,11 @@ TraversalCode WhileStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> WhileStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr WhileStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
zeek::IntrusivePtr<Val> rval;
ValPtr rval;
for ( ; ; )
{
@ -1060,7 +1060,7 @@ zeek::IntrusivePtr<Val> WhileStmt::Exec(Frame* f, stmt_flow_type& flow) const
return rval;
}
ForStmt::ForStmt(id_list* arg_loop_vars, zeek::IntrusivePtr<Expr> loop_expr)
ForStmt::ForStmt(id_list* arg_loop_vars, ExprPtr loop_expr)
: ExprStmt(STMT_FOR, std::move(loop_expr))
{
loop_vars = arg_loop_vars;
@ -1143,7 +1143,7 @@ ForStmt::ForStmt(id_list* arg_loop_vars, zeek::IntrusivePtr<Expr> loop_expr)
}
ForStmt::ForStmt(id_list* arg_loop_vars,
zeek::IntrusivePtr<Expr> loop_expr, zeek::IntrusivePtr<ID> val_var)
ExprPtr loop_expr, IDPtr val_var)
: ForStmt(arg_loop_vars, std::move(loop_expr))
{
value_var = std::move(val_var);
@ -1174,9 +1174,9 @@ ForStmt::~ForStmt()
delete loop_vars;
}
zeek::IntrusivePtr<Val> ForStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
ValPtr ForStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
{
zeek::IntrusivePtr<Val> ret;
ValPtr ret;
if ( v->GetType()->Tag() == TYPE_TABLE )
{
@ -1332,7 +1332,7 @@ TraversalCode ForStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> NextStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
ValPtr NextStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_LOOP;
@ -1359,7 +1359,7 @@ TraversalCode NextStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> BreakStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
ValPtr BreakStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_BREAK;
@ -1386,7 +1386,7 @@ TraversalCode BreakStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> FallthroughStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
ValPtr FallthroughStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_FALLTHROUGH;
@ -1413,7 +1413,7 @@ TraversalCode FallthroughStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
ReturnStmt::ReturnStmt(zeek::IntrusivePtr<Expr> arg_e)
ReturnStmt::ReturnStmt(ExprPtr arg_e)
: ExprStmt(STMT_RETURN, std::move(arg_e))
{
Scope* s = current_scope();
@ -1457,7 +1457,7 @@ ReturnStmt::ReturnStmt(zeek::IntrusivePtr<Expr> arg_e)
}
}
zeek::IntrusivePtr<Val> ReturnStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr ReturnStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_RETURN;
@ -1496,7 +1496,7 @@ StmtList::~StmtList()
Unref(stmt);
}
zeek::IntrusivePtr<Val> StmtList::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr StmtList::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -1575,7 +1575,7 @@ TraversalCode StmtList::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> EventBodyList::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr EventBodyList::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -1633,7 +1633,7 @@ void EventBodyList::Describe(ODesc* d) const
StmtList::Describe(d);
}
InitStmt::InitStmt(std::vector<zeek::IntrusivePtr<ID>> arg_inits) : Stmt(STMT_INIT)
InitStmt::InitStmt(std::vector<IDPtr> arg_inits) : Stmt(STMT_INIT)
{
inits = std::move(arg_inits);
@ -1641,7 +1641,7 @@ InitStmt::InitStmt(std::vector<zeek::IntrusivePtr<ID>> arg_inits) : Stmt(STMT_IN
SetLocationInfo(inits[0]->GetLocationInfo());
}
zeek::IntrusivePtr<Val> InitStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr InitStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -1650,7 +1650,7 @@ zeek::IntrusivePtr<Val> InitStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
const auto& t = aggr->GetType();
zeek::IntrusivePtr<Val> v;
ValPtr v;
switch ( t->Tag() ) {
case TYPE_RECORD:
@ -1706,7 +1706,7 @@ TraversalCode InitStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
zeek::IntrusivePtr<Val> NullStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
ValPtr NullStmt::Exec(Frame* /* f */, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;
@ -1735,9 +1735,9 @@ TraversalCode NullStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_POST(tc);
}
WhenStmt::WhenStmt(zeek::IntrusivePtr<Expr> arg_cond,
zeek::IntrusivePtr<Stmt> arg_s1, zeek::IntrusivePtr<Stmt> arg_s2,
zeek::IntrusivePtr<Expr> arg_timeout, bool arg_is_return)
WhenStmt::WhenStmt(ExprPtr arg_cond,
StmtPtr arg_s1, StmtPtr arg_s2,
ExprPtr arg_timeout, bool arg_is_return)
: Stmt(STMT_WHEN),
cond(std::move(arg_cond)), s1(std::move(arg_s1)), s2(std::move(arg_s2)),
timeout(std::move(arg_timeout)), is_return(arg_is_return)
@ -1761,7 +1761,7 @@ WhenStmt::WhenStmt(zeek::IntrusivePtr<Expr> arg_cond,
WhenStmt::~WhenStmt() = default;
zeek::IntrusivePtr<Val> WhenStmt::Exec(Frame* f, stmt_flow_type& flow) const
ValPtr WhenStmt::Exec(Frame* f, stmt_flow_type& flow) const
{
RegisterAccess();
flow = FLOW_NEXT;

124
src/Stmt.h
View file

@ -23,13 +23,19 @@ class ForStmt;
class EventExpr;
class ListExpr;
using EventExprPtr = zeek::IntrusivePtr<EventExpr>;
using ListExprPtr = zeek::IntrusivePtr<ListExpr>;
class Stmt;
using StmtPtr = zeek::IntrusivePtr<Stmt>;
class Stmt : public BroObj {
public:
BroStmtTag Tag() const { return tag; }
~Stmt() override;
virtual zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const = 0;
virtual ValPtr Exec(Frame* f, stmt_flow_type& flow) const = 0;
Stmt* Ref() { ::Ref(this); return this; }
@ -93,17 +99,17 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
ExprListStmt(BroStmtTag t, zeek::IntrusivePtr<ListExpr> arg_l);
ExprListStmt(BroStmtTag t, ListExprPtr arg_l);
~ExprListStmt() override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
virtual zeek::IntrusivePtr<Val> DoExec(std::vector<zeek::IntrusivePtr<Val>> vals,
stmt_flow_type& flow) const = 0;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
virtual ValPtr DoExec(std::vector<ValPtr> vals,
stmt_flow_type& flow) const = 0;
void Describe(ODesc* d) const override;
zeek::IntrusivePtr<ListExpr> l;
ListExprPtr l;
};
class PrintStmt final : public ExprListStmt {
@ -112,16 +118,16 @@ public:
explicit PrintStmt(L&& l) : ExprListStmt(STMT_PRINT, std::forward<L>(l)) { }
protected:
zeek::IntrusivePtr<Val> DoExec(std::vector<zeek::IntrusivePtr<Val>> vals,
stmt_flow_type& flow) const override;
ValPtr DoExec(std::vector<ValPtr> vals,
stmt_flow_type& flow) const override;
};
class ExprStmt : public Stmt {
public:
explicit ExprStmt(zeek::IntrusivePtr<Expr> e);
explicit ExprStmt(ExprPtr e);
~ExprStmt() override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
const Expr* StmtExpr() const { return e.get(); }
@ -130,18 +136,18 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
ExprStmt(BroStmtTag t, zeek::IntrusivePtr<Expr> e);
ExprStmt(BroStmtTag t, ExprPtr e);
virtual zeek::IntrusivePtr<Val> DoExec(Frame* f, Val* v, stmt_flow_type& flow) const;
virtual ValPtr DoExec(Frame* f, Val* v, stmt_flow_type& flow) const;
bool IsPure() const override;
zeek::IntrusivePtr<Expr> e;
ExprPtr e;
};
class IfStmt final : public ExprStmt {
public:
IfStmt(zeek::IntrusivePtr<Expr> test, zeek::IntrusivePtr<Stmt> s1, zeek::IntrusivePtr<Stmt> s2);
IfStmt(ExprPtr test, StmtPtr s1, StmtPtr s2);
~IfStmt() override;
const Stmt* TrueBranch() const { return s1.get(); }
@ -152,16 +158,16 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Val> DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
ValPtr DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
bool IsPure() const override;
zeek::IntrusivePtr<Stmt> s1;
zeek::IntrusivePtr<Stmt> s2;
StmtPtr s1;
StmtPtr s2;
};
class Case final : public BroObj {
public:
Case(zeek::IntrusivePtr<ListExpr> c, id_list* types, zeek::IntrusivePtr<Stmt> arg_s);
Case(ListExprPtr c, id_list* types, StmtPtr arg_s);
~Case() override;
const ListExpr* ExprCases() const { return expr_cases.get(); }
@ -178,16 +184,16 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const;
protected:
zeek::IntrusivePtr<ListExpr> expr_cases;
ListExprPtr expr_cases;
id_list* type_cases;
zeek::IntrusivePtr<Stmt> s;
StmtPtr s;
};
using case_list = PList<Case>;
class SwitchStmt final : public ExprStmt {
public:
SwitchStmt(zeek::IntrusivePtr<Expr> index, case_list* cases);
SwitchStmt(ExprPtr index, case_list* cases);
~SwitchStmt() override;
const case_list* Cases() const { return cases; }
@ -197,7 +203,7 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Val> DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
ValPtr DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
bool IsPure() const override;
// Initialize composite hash and case label map.
@ -228,40 +234,40 @@ protected:
class AddStmt final : public ExprStmt {
public:
explicit AddStmt(zeek::IntrusivePtr<Expr> e);
explicit AddStmt(ExprPtr e);
bool IsPure() const override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
};
class DelStmt final : public ExprStmt {
public:
explicit DelStmt(zeek::IntrusivePtr<Expr> e);
explicit DelStmt(ExprPtr e);
bool IsPure() const override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
};
class EventStmt final : public ExprStmt {
public:
explicit EventStmt(zeek::IntrusivePtr<EventExpr> e);
explicit EventStmt(EventExprPtr e);
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<EventExpr> event_expr;
EventExprPtr event_expr;
};
class WhileStmt final : public Stmt {
public:
WhileStmt(zeek::IntrusivePtr<Expr> loop_condition, zeek::IntrusivePtr<Stmt> body);
WhileStmt(ExprPtr loop_condition, StmtPtr body);
~WhileStmt() override;
bool IsPure() const override;
@ -271,20 +277,20 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
zeek::IntrusivePtr<Expr> loop_condition;
zeek::IntrusivePtr<Stmt> body;
ExprPtr loop_condition;
StmtPtr body;
};
class ForStmt final : public ExprStmt {
public:
ForStmt(id_list* loop_vars, zeek::IntrusivePtr<Expr> loop_expr);
ForStmt(id_list* loop_vars, ExprPtr loop_expr);
// Special constructor for key value for loop.
ForStmt(id_list* loop_vars, zeek::IntrusivePtr<Expr> loop_expr, zeek::IntrusivePtr<ID> val_var);
ForStmt(id_list* loop_vars, ExprPtr loop_expr, IDPtr val_var);
~ForStmt() override;
void AddBody(zeek::IntrusivePtr<Stmt> arg_body) { body = std::move(arg_body); }
void AddBody(StmtPtr arg_body) { body = std::move(arg_body); }
const id_list* LoopVar() const { return loop_vars; }
const Expr* LoopExpr() const { return e.get(); }
@ -297,20 +303,20 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Val> DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
ValPtr DoExec(Frame* f, Val* v, stmt_flow_type& flow) const override;
id_list* loop_vars;
zeek::IntrusivePtr<Stmt> body;
StmtPtr body;
// Stores the value variable being used for a key value for loop.
// Always set to nullptr unless special constructor is called.
zeek::IntrusivePtr<ID> value_var;
IDPtr value_var;
};
class NextStmt final : public Stmt {
public:
NextStmt() : Stmt(STMT_NEXT) { }
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
bool IsPure() const override;
void Describe(ODesc* d) const override;
@ -324,7 +330,7 @@ class BreakStmt final : public Stmt {
public:
BreakStmt() : Stmt(STMT_BREAK) { }
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
bool IsPure() const override;
void Describe(ODesc* d) const override;
@ -338,7 +344,7 @@ class FallthroughStmt final : public Stmt {
public:
FallthroughStmt() : Stmt(STMT_FALLTHROUGH) { }
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
bool IsPure() const override;
void Describe(ODesc* d) const override;
@ -350,9 +356,9 @@ protected:
class ReturnStmt final : public ExprStmt {
public:
explicit ReturnStmt(zeek::IntrusivePtr<Expr> e);
explicit ReturnStmt(ExprPtr e);
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
void Describe(ODesc* d) const override;
};
@ -362,7 +368,7 @@ public:
StmtList();
~StmtList() override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
const stmt_list& Stmts() const { return stmts; }
stmt_list& Stmts() { return stmts; }
@ -382,7 +388,7 @@ public:
EventBodyList() : StmtList()
{ topmost = false; tag = STMT_EVENT_BODY_LIST; }
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
void Describe(ODesc* d) const override;
@ -396,11 +402,11 @@ protected:
class InitStmt final : public Stmt {
public:
explicit InitStmt(std::vector<zeek::IntrusivePtr<ID>> arg_inits);
explicit InitStmt(std::vector<IDPtr> arg_inits);
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
const std::vector<zeek::IntrusivePtr<ID>>& Inits() const
const std::vector<IDPtr>& Inits() const
{ return inits; }
void Describe(ODesc* d) const override;
@ -408,14 +414,14 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
std::vector<zeek::IntrusivePtr<ID>> inits;
std::vector<IDPtr> inits;
};
class NullStmt final : public Stmt {
public:
NullStmt() : Stmt(STMT_NULL) { }
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
bool IsPure() const override;
void Describe(ODesc* d) const override;
@ -426,12 +432,12 @@ public:
class WhenStmt final : public Stmt {
public:
// s2 is null if no timeout block given.
WhenStmt(zeek::IntrusivePtr<Expr> cond,
zeek::IntrusivePtr<Stmt> s1, zeek::IntrusivePtr<Stmt> s2,
zeek::IntrusivePtr<Expr> timeout, bool is_return);
WhenStmt(ExprPtr cond,
StmtPtr s1, StmtPtr s2,
ExprPtr timeout, bool is_return);
~WhenStmt() override;
zeek::IntrusivePtr<Val> Exec(Frame* f, stmt_flow_type& flow) const override;
ValPtr Exec(Frame* f, stmt_flow_type& flow) const override;
bool IsPure() const override;
const Expr* Cond() const { return cond.get(); }
@ -444,10 +450,10 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
zeek::IntrusivePtr<Expr> cond;
zeek::IntrusivePtr<Stmt> s1;
zeek::IntrusivePtr<Stmt> s2;
zeek::IntrusivePtr<Expr> timeout;
ExprPtr cond;
StmtPtr s1;
StmtPtr s2;
ExprPtr timeout;
bool is_return;
};

7
src/Tag.cc
View file

@ -2,9 +2,8 @@
#include "Tag.h"
#include "Val.h"
#include "IntrusivePtr.h"
Tag::Tag(const zeek::IntrusivePtr<zeek::EnumType>& etype, type_t arg_type, subtype_t arg_subtype)
Tag::Tag(const zeek::EnumTypePtr& etype, type_t arg_type, subtype_t arg_subtype)
{
assert(arg_type > 0);
@ -18,7 +17,7 @@ Tag::Tag(zeek::EnumType* etype, type_t arg_type, subtype_t arg_subtype)
: Tag({zeek::NewRef{}, etype}, arg_type, arg_subtype)
{ }
Tag::Tag(zeek::IntrusivePtr<EnumVal> arg_val)
Tag::Tag(EnumValPtr arg_val)
{
assert(arg_val);
@ -73,7 +72,7 @@ Tag& Tag::operator=(const Tag&& other) noexcept
return *this;
}
const zeek::IntrusivePtr<EnumVal>& Tag::AsVal(const zeek::IntrusivePtr<zeek::EnumType>& etype) const
const EnumValPtr& Tag::AsVal(const zeek::EnumTypePtr& etype) const
{
if ( ! val )
{

13
src/Tag.h
View file

@ -11,7 +11,12 @@
#include "util.h"
class EnumVal;
using EnumValPtr = zeek::IntrusivePtr<EnumVal>;
ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek);
namespace zeek {
using EnumTypePtr = zeek::IntrusivePtr<zeek::EnumType>;
}
/**
* Class to identify an analyzer type.
@ -116,7 +121,7 @@ protected:
*
* @param etype the script-layer enum type associated with the tag.
*/
const zeek::IntrusivePtr<EnumVal>& AsVal(const zeek::IntrusivePtr<zeek::EnumType>& etype) const;
const EnumValPtr& AsVal(const zeek::EnumTypePtr& etype) const;
[[deprecated("Remove in v4.1. Use AsVal() instead.")]]
EnumVal* AsEnumVal(zeek::EnumType* etype) const;
@ -132,7 +137,7 @@ protected:
* @param subtype The sub type, which is left to an analyzer for
* interpretation. By default it's set to zero.
*/
Tag(const zeek::IntrusivePtr<zeek::EnumType>& etype, type_t type, subtype_t subtype = 0);
Tag(const zeek::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);
@ -142,7 +147,7 @@ protected:
*
* @param val An enum value of script type \c Analyzer::Tag.
*/
explicit Tag(zeek::IntrusivePtr<EnumVal> val);
explicit Tag(EnumValPtr val);
[[deprecated("Remove in v4.1. Construct from zeek::IntrusivePtr instead.")]]
explicit Tag(EnumVal* val);
@ -150,5 +155,5 @@ protected:
private:
type_t type; // Main type.
subtype_t subtype; // Subtype.
mutable zeek::IntrusivePtr<EnumVal> val; // Script-layer value.
mutable EnumValPtr val; // Script-layer value.
};

8
src/Trigger.cc
View file

@ -151,7 +151,7 @@ Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body,
arg_frame->SetDelayed();
}
zeek::IntrusivePtr<Val> timeout_val;
ValPtr timeout_val;
if ( arg_timeout )
{
@ -264,7 +264,7 @@ bool Trigger::Eval()
f->SetTrigger({zeek::NewRef{}, this});
zeek::IntrusivePtr<Val> v;
ValPtr v;
try
{
@ -348,8 +348,8 @@ void Trigger::Timeout()
if ( timeout_stmts )
{
stmt_flow_type flow;
zeek::IntrusivePtr<Frame> f{zeek::AdoptRef{}, frame->Clone()};
zeek::IntrusivePtr<Val> v;
FramePtr f{zeek::AdoptRef{}, frame->Clone()};
ValPtr v;
try
{

3
src/Trigger.h
View file

@ -8,6 +8,7 @@
#include "Notifier.h"
#include "iosource/IOSource.h"
#include "util.h"
#include "IntrusivePtr.h"
class Frame;
class Val;
@ -115,6 +116,8 @@ private:
ValCache cache;
};
using TriggerPtr = zeek::IntrusivePtr<Trigger>;
class Manager final : public iosource::IOSource {
public:

2
src/TunnelEncapsulation.cc
View file

@ -16,7 +16,7 @@ EncapsulatingConn::EncapsulatingConn(Connection* c, BifEnum::Tunnel::Type t)
}
}
zeek::IntrusivePtr<RecordVal> EncapsulatingConn::ToVal() const
RecordValPtr EncapsulatingConn::ToVal() const
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::Tunnel::EncapsulatingConn);

5
src/TunnelEncapsulation.h
View file

@ -6,7 +6,6 @@
#include <vector>
#include "IntrusivePtr.h"
#include "NetVar.h"
#include "IPAddr.h"
#include "ID.h"
@ -81,7 +80,7 @@ public:
/**
* Returns record value of type "EncapsulatingConn" representing the tunnel.
*/
zeek::IntrusivePtr<RecordVal> ToVal() const;
RecordValPtr ToVal() const;
[[deprecated("Remove in v4.1. Use ToVal() instead.")]]
RecordVal* GetRecordVal() const
@ -196,7 +195,7 @@ public:
* Get the value of type "EncapsulatingConnVector" represented by the
* entire encapsulation chain.
*/
zeek::IntrusivePtr<VectorVal> ToVal() const
VectorValPtr ToVal() const
{
auto vv = zeek::make_intrusive<VectorVal>(
zeek::id::find_type<zeek::VectorType>("EncapsulatingConnVector"));

69
src/Type.cc
View file

@ -71,7 +71,7 @@ Type::Type(zeek::TypeTag t, bool arg_base_type)
{
}
zeek::IntrusivePtr<Type> Type::ShallowClone()
TypePtr Type::ShallowClone()
{
switch ( tag ) {
case TYPE_VOID:
@ -111,7 +111,7 @@ int Type::MatchesIndex(zeek::detail::ListExpr* const index) const
return DOES_NOT_MATCH_INDEX;
}
const zeek::IntrusivePtr<Type>& Type::Yield() const
const TypePtr& Type::Yield() const
{
return Type::nil;
}
@ -163,7 +163,7 @@ bool TypeList::AllMatch(const Type* t, bool is_init) const
return true;
}
void TypeList::Append(zeek::IntrusivePtr<Type> t)
void TypeList::Append(TypePtr t)
{
if ( pure_type && ! same_type(t, pure_type) )
reporter->InternalError("pure type-list violation");
@ -172,7 +172,7 @@ void TypeList::Append(zeek::IntrusivePtr<Type> t)
types.emplace_back(std::move(t));
}
void TypeList::AppendEvenIfNotPure(zeek::IntrusivePtr<Type> t)
void TypeList::AppendEvenIfNotPure(TypePtr t)
{
if ( pure_type && ! same_type(t, pure_type) )
pure_type = nullptr;
@ -317,7 +317,7 @@ bool IndexType::IsSubNetIndex() const
return false;
}
TableType::TableType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<Type> yield)
TableType::TableType(TypeListPtr ind, TypePtr yield)
: IndexType(TYPE_TABLE, std::move(ind), std::move(yield))
{
if ( ! indices )
@ -344,7 +344,7 @@ TableType::TableType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<Type>
}
}
zeek::IntrusivePtr<Type> TableType::ShallowClone()
TypePtr TableType::ShallowClone()
{
return zeek::make_intrusive<TableType>(indices, yield_type);
}
@ -355,7 +355,7 @@ bool TableType::IsUnspecifiedTable() const
return indices->GetTypes().empty();
}
SetType::SetType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<zeek::detail::ListExpr> arg_elements)
SetType::SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements)
: TableType(std::move(ind), nullptr), elements(std::move(arg_elements))
{
if ( elements )
@ -378,7 +378,7 @@ SetType::SetType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<zeek::deta
else if ( tl.size() == 1 )
{
zeek::IntrusivePtr<Type> ft{zeek::NewRef{}, flatten_type(tl[0].get())};
TypePtr ft{zeek::NewRef{}, flatten_type(tl[0].get())};
indices = zeek::make_intrusive<TypeList>(ft);
indices->Append(std::move(ft));
}
@ -403,15 +403,15 @@ SetType::SetType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<zeek::deta
}
}
zeek::IntrusivePtr<Type> SetType::ShallowClone()
TypePtr SetType::ShallowClone()
{
return zeek::make_intrusive<SetType>(indices, elements);
}
SetType::~SetType() = default;
FuncType::FuncType(zeek::IntrusivePtr<RecordType> arg_args,
zeek::IntrusivePtr<Type> arg_yield, FunctionFlavor arg_flavor)
FuncType::FuncType(RecordTypePtr arg_args,
TypePtr arg_yield, FunctionFlavor arg_flavor)
: Type(TYPE_FUNC), args(std::move(arg_args)),
arg_types(zeek::make_intrusive<TypeList>()), yield(std::move(arg_yield))
{
@ -441,7 +441,7 @@ FuncType::FuncType(zeek::IntrusivePtr<RecordType> arg_args,
prototypes.emplace_back(Prototype{false, args, std::move(offsets)});
}
zeek::IntrusivePtr<Type> FuncType::ShallowClone()
TypePtr FuncType::ShallowClone()
{
auto f = zeek::make_intrusive<FuncType>();
f->args = args;
@ -481,7 +481,7 @@ int FuncType::MatchesIndex(zeek::detail::ListExpr* const index) const
bool FuncType::CheckArgs(const type_list* args, bool is_init) const
{
std::vector<zeek::IntrusivePtr<Type>> as;
std::vector<TypePtr> as;
as.reserve(args->length());
for ( auto a : *args )
@ -490,7 +490,7 @@ bool FuncType::CheckArgs(const type_list* args, bool is_init) const
return CheckArgs(as, is_init);
}
bool FuncType::CheckArgs(const std::vector<zeek::IntrusivePtr<Type>>& args,
bool FuncType::CheckArgs(const std::vector<TypePtr>& args,
bool is_init) const
{
const auto& my_args = arg_types->GetTypes();
@ -609,8 +609,7 @@ std::optional<FuncType::Prototype> FuncType::FindPrototype(const RecordType& arg
return {};
}
TypeDecl::TypeDecl(const char* i, zeek::IntrusivePtr<Type> t,
zeek::IntrusivePtr<zeek::detail::Attributes> arg_attrs)
TypeDecl::TypeDecl(const char* i, TypePtr t, zeek::detail::AttributesPtr arg_attrs)
: type(std::move(t)),
attrs(std::move(arg_attrs)),
id(i)
@ -658,7 +657,7 @@ RecordType::RecordType(type_decl_list* arg_types) : Type(TYPE_RECORD)
// in this case the clone is actually not so shallow, since
// it gets modified by everyone.
zeek::IntrusivePtr<Type> RecordType::ShallowClone()
TypePtr RecordType::ShallowClone()
{
auto pass = new type_decl_list();
for ( const auto& type : *types )
@ -682,7 +681,7 @@ bool RecordType::HasField(const char* field) const
return FieldOffset(field) >= 0;
}
zeek::IntrusivePtr<Val> RecordType::FieldDefault(int field) const
ValPtr RecordType::FieldDefault(int field) const
{
const TypeDecl* td = FieldDecl(field);
@ -794,7 +793,7 @@ static string container_type_name(const Type* ft)
return s;
}
zeek::IntrusivePtr<TableVal> RecordType::GetRecordFieldsVal(const RecordVal* rv) const
TableValPtr RecordType::GetRecordFieldsVal(const RecordVal* rv) const
{
static auto record_field = zeek::id::find_type<RecordType>("record_field");
static auto record_field_table = zeek::id::find_type<TableType>("record_field_table");
@ -804,7 +803,7 @@ zeek::IntrusivePtr<TableVal> RecordType::GetRecordFieldsVal(const RecordVal* rv)
{
const auto& ft = GetFieldType(i);
const TypeDecl* fd = FieldDecl(i);
zeek::IntrusivePtr<Val> fv;
ValPtr fv;
if ( rv )
fv = rv->GetField(i);
@ -1028,7 +1027,7 @@ void SubNetType::Describe(ODesc* d) const
d->Add(int(Tag()));
}
FileType::FileType(zeek::IntrusivePtr<Type> yield_type)
FileType::FileType(TypePtr yield_type)
: Type(TYPE_FILE), yield(std::move(yield_type))
{
}
@ -1083,7 +1082,7 @@ EnumType::EnumType(const EnumType* e)
SetName(e->GetName());
}
zeek::IntrusivePtr<Type> EnumType::ShallowClone()
TypePtr EnumType::ShallowClone()
{
if ( counter == 0 )
return zeek::make_intrusive<EnumType>(GetName());
@ -1213,7 +1212,7 @@ EnumType::enum_name_list EnumType::Names() const
return n;
}
const zeek::IntrusivePtr<EnumVal>& EnumType::GetVal(bro_int_t i)
const EnumValPtr& EnumType::GetVal(bro_int_t i)
{
auto it = vals.find(i);
@ -1303,19 +1302,19 @@ void EnumType::DescribeReST(ODesc* d, bool roles_only) const
}
}
VectorType::VectorType(zeek::IntrusivePtr<Type> element_type)
VectorType::VectorType(TypePtr element_type)
: Type(TYPE_VECTOR), yield_type(std::move(element_type))
{
}
zeek::IntrusivePtr<Type> VectorType::ShallowClone()
TypePtr VectorType::ShallowClone()
{
return zeek::make_intrusive<VectorType>(yield_type);
}
VectorType::~VectorType() = default;
const zeek::IntrusivePtr<Type>& VectorType::Yield() const
const TypePtr& VectorType::Yield() const
{
// Work around the fact that we use void internally to mark a vector
// as being unspecified. When looking at its yield type, we need to
@ -1684,8 +1683,8 @@ TypeTag max_type(TypeTag t1, TypeTag t2)
}
}
zeek::IntrusivePtr<Type> merge_types(const zeek::IntrusivePtr<Type>& arg_t1,
const zeek::IntrusivePtr<Type>& arg_t2)
TypePtr merge_types(const TypePtr& arg_t1,
const TypePtr& arg_t2)
{
auto t1 = arg_t1.get();
auto t2 = arg_t2.get();
@ -1758,7 +1757,7 @@ zeek::IntrusivePtr<Type> merge_types(const zeek::IntrusivePtr<Type>& arg_t1,
const auto& tl1 = it1->GetIndexTypes();
const auto& tl2 = it2->GetIndexTypes();
zeek::IntrusivePtr<TypeList> tl3;
TypeListPtr tl3;
if ( tl1.size() != tl2.size() )
{
@ -1779,7 +1778,7 @@ zeek::IntrusivePtr<Type> merge_types(const zeek::IntrusivePtr<Type>& arg_t1,
const auto& y1 = t1->Yield();
const auto& y2 = t2->Yield();
zeek::IntrusivePtr<Type> y3;
TypePtr y3;
if ( y1 || y2 )
{
@ -1924,7 +1923,7 @@ zeek::IntrusivePtr<Type> merge_types(const zeek::IntrusivePtr<Type>& arg_t1,
}
}
zeek::IntrusivePtr<Type> merge_type_list(zeek::detail::ListExpr* elements)
TypePtr merge_type_list(zeek::detail::ListExpr* elements)
{
TypeList* tl_type = elements->GetType()->AsTypeList();
const auto& tl = tl_type->GetTypes();
@ -1969,7 +1968,7 @@ static Type* reduce_type(Type* t)
return t;
}
zeek::IntrusivePtr<Type> init_type(zeek::detail::Expr* init)
TypePtr init_type(zeek::detail::Expr* init)
{
if ( init->Tag() != zeek::detail::EXPR_LIST )
{
@ -2016,7 +2015,7 @@ zeek::IntrusivePtr<Type> init_type(zeek::detail::Expr* init)
for ( int i = 1; t && i < el.length(); ++i )
{
auto el_t = el[i]->InitType();
zeek::IntrusivePtr<Type> ti;
TypePtr ti;
if ( el_t )
ti = {zeek::NewRef{}, reduce_type(el_t.get())};
@ -2068,9 +2067,9 @@ bool is_atomic_type(const Type& t)
}
}
const zeek::IntrusivePtr<Type>& base_type(zeek::TypeTag tag)
const TypePtr& base_type(zeek::TypeTag tag)
{
static zeek::IntrusivePtr<Type> base_types[NUM_TYPES];
static TypePtr base_types[NUM_TYPES];
// We could check here that "tag" actually corresponds to a basic type.
if ( ! base_types[tag] )

186
src/Type.h
View file

@ -18,10 +18,18 @@ class Val;
class EnumVal;
class TableVal;
using ValPtr = zeek::IntrusivePtr<Val>;
using EnumValPtr = zeek::IntrusivePtr<EnumVal>;
using TableValPtr = zeek::IntrusivePtr<TableVal>;
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(ListExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail);
namespace zeek::detail {
using ListExprPtr = zeek::IntrusivePtr<ListExpr>;
}
namespace zeek {
// BRO types.
@ -139,6 +147,20 @@ class EnumType;
class VectorType;
class TypeType;
class OpaqueType;
class FileType;
using TypePtr = zeek::IntrusivePtr<Type>;
using TypeListPtr = zeek::IntrusivePtr<TypeList>;
using TableTypePtr = zeek::IntrusivePtr<TableType>;
using SetTypePtr = zeek::IntrusivePtr<SetType>;
using RecordTypePtr = zeek::IntrusivePtr<RecordType>;
using SubNetTypePtr = zeek::IntrusivePtr<SubNetType>;
using FuncTypePtr = zeek::IntrusivePtr<FuncType>;
using EnumTypePtr = zeek::IntrusivePtr<EnumType>;
using VectorTypePtr = zeek::IntrusivePtr<VectorType>;
using TypeTypePtr = zeek::IntrusivePtr<TypeType>;
using OpaqueTypePtr = zeek::IntrusivePtr<OpaqueType>;
using FileTypePtr = zeek::IntrusivePtr<FileType>;
constexpr int DOES_NOT_MATCH_INDEX = 0;
constexpr int MATCHES_INDEX_SCALAR = 1;
@ -146,7 +168,7 @@ constexpr int MATCHES_INDEX_VECTOR = 2;
class Type : public BroObj {
public:
static inline const zeek::IntrusivePtr<Type> nil;
static inline const TypePtr nil;
explicit Type(zeek::TypeTag tag, bool base_type = false);
@ -158,7 +180,7 @@ public:
// Clone operations will mostly be implemented in the derived classes;
// in addition cloning will be limited to classes that can be reached by
// the script-level.
virtual zeek::IntrusivePtr<Type> ShallowClone();
virtual TypePtr ShallowClone();
TypeTag Tag() const { return tag; }
InternalTypeTag InternalType() const { return internal_tag; }
@ -178,7 +200,7 @@ public:
// Returns the type yielded by this type. For example, if
// this type is a table[string] of port, then returns the "port"
// type. Returns nil if this is not an index type.
virtual const zeek::IntrusivePtr<Type>& Yield() const;
virtual const TypePtr& Yield() const;
[[deprecated("Remove in v4.1. Use Yield() instead.")]]
virtual Type* YieldType()
@ -362,7 +384,7 @@ private:
class TypeList final : public Type {
public:
explicit TypeList(zeek::IntrusivePtr<Type> arg_pure_type = nullptr)
explicit TypeList(TypePtr arg_pure_type = nullptr)
: Type(TYPE_LIST), pure_type(std::move(arg_pure_type))
{
}
@ -373,14 +395,14 @@ public:
const type_list* Types() const
{ return &types_list; }
const std::vector<zeek::IntrusivePtr<Type>>& GetTypes() const
const std::vector<TypePtr>& GetTypes() const
{ return types; }
bool IsPure() const { return pure_type != nullptr; }
// Returns the underlying pure type, or nil if the list
// is not pure or is empty.
const zeek::IntrusivePtr<Type>& GetPureType() const
const TypePtr& GetPureType() const
{ return pure_type; }
[[deprecated("Remove in v4.1. Use GetPureType() instead.")]]
@ -392,19 +414,19 @@ public:
// is_init is true, then the matching is done in the context
// of an initialization.
bool AllMatch(const Type* t, bool is_init) const;
bool AllMatch(const zeek::IntrusivePtr<Type>& t, bool is_init) const
bool AllMatch(const TypePtr& t, bool is_init) const
{ return AllMatch(t.get(), is_init); }
void Append(zeek::IntrusivePtr<Type> t);
void AppendEvenIfNotPure(zeek::IntrusivePtr<Type> t);
void Append(TypePtr t);
void AppendEvenIfNotPure(TypePtr t);
void Describe(ODesc* d) const override;
unsigned int MemoryAllocation() const override;
protected:
zeek::IntrusivePtr<Type> pure_type;
std::vector<zeek::IntrusivePtr<Type>> types;
TypePtr pure_type;
std::vector<TypePtr> types;
// Remove in v4.1. This is used by Types(), which is deprecated.
type_list types_list;
@ -415,7 +437,7 @@ public:
int MatchesIndex(zeek::detail::ListExpr* index) const override;
const zeek::IntrusivePtr<TypeList>& GetIndices() const
const TypeListPtr& GetIndices() const
{ return indices; }
[[deprecated("Remove in v4.1. Use GetIndices().")]]
@ -425,10 +447,10 @@ public:
const type_list* IndexTypes() const
{ return indices->Types(); }
const std::vector<zeek::IntrusivePtr<Type>>& GetIndexTypes() const
const std::vector<TypePtr>& GetIndexTypes() const
{ return indices->GetTypes(); }
const zeek::IntrusivePtr<Type>& Yield() const override
const TypePtr& Yield() const override
{ return yield_type; }
void Describe(ODesc* d) const override;
@ -438,8 +460,8 @@ public:
bool IsSubNetIndex() const;
protected:
IndexType(TypeTag t, zeek::IntrusivePtr<TypeList> arg_indices,
zeek::IntrusivePtr<Type> arg_yield_type)
IndexType(TypeTag t, TypeListPtr arg_indices,
TypePtr arg_yield_type)
: Type(t), indices(std::move(arg_indices)),
yield_type(std::move(arg_yield_type))
{
@ -447,15 +469,15 @@ protected:
~IndexType() override = default;
zeek::IntrusivePtr<TypeList> indices;
zeek::IntrusivePtr<Type> yield_type;
TypeListPtr indices;
TypePtr yield_type;
};
class TableType : public IndexType {
public:
TableType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<Type> yield);
TableType(TypeListPtr ind, TypePtr yield);
zeek::IntrusivePtr<Type> ShallowClone() override;
TypePtr ShallowClone() override;
// Returns true if this table type is "unspecified", which is
// what one gets using an empty "set()" or "table()" constructor.
@ -464,24 +486,24 @@ public:
class SetType final : public TableType {
public:
SetType(zeek::IntrusivePtr<TypeList> ind, zeek::IntrusivePtr<zeek::detail::ListExpr> arg_elements);
SetType(TypeListPtr ind, zeek::detail::ListExprPtr arg_elements);
~SetType() override;
zeek::IntrusivePtr<Type> ShallowClone() override;
TypePtr ShallowClone() override;
[[deprecated("Remove in v4.1. Use Elements() isntead.")]]
zeek::detail::ListExpr* SetElements() const { return elements.get(); }
const zeek::IntrusivePtr<zeek::detail::ListExpr>& Elements() const
const zeek::detail::ListExprPtr& Elements() const
{ return elements; }
protected:
zeek::IntrusivePtr<zeek::detail::ListExpr> elements;
zeek::detail::ListExprPtr elements;
};
class FuncType final : public Type {
public:
static inline const zeek::IntrusivePtr<FuncType> nil;
static inline const FuncTypePtr nil;
/**
* Prototype is only currently used for events and hooks which declare
@ -490,27 +512,27 @@ public:
*/
struct Prototype {
bool deprecated;
zeek::IntrusivePtr<RecordType> args;
RecordTypePtr args;
std::map<int, int> offsets;
};
FuncType(zeek::IntrusivePtr<RecordType> args, zeek::IntrusivePtr<Type> yield,
FuncType(RecordTypePtr args, TypePtr yield,
FunctionFlavor f);
zeek::IntrusivePtr<Type> ShallowClone() override;
TypePtr ShallowClone() override;
~FuncType() override;
[[deprecated("Remove in v4.1. Use Params().")]]
RecordType* Args() const { return args.get(); }
const zeek::IntrusivePtr<RecordType>& Params() const
const RecordTypePtr& Params() const
{ return args; }
const zeek::IntrusivePtr<Type>& Yield() const override
const TypePtr& Yield() const override
{ return yield; }
void SetYieldType(zeek::IntrusivePtr<Type> arg_yield) { yield = std::move(arg_yield); }
void SetYieldType(TypePtr arg_yield) { yield = std::move(arg_yield); }
FunctionFlavor Flavor() const { return flavor; }
std::string FlavorString() const;
@ -520,13 +542,13 @@ public:
int MatchesIndex(zeek::detail::ListExpr* index) const override;
bool CheckArgs(const type_list* args, bool is_init = false) const;
bool CheckArgs(const std::vector<zeek::IntrusivePtr<Type>>& args,
bool CheckArgs(const std::vector<TypePtr>& args,
bool is_init = false) const;
[[deprecated("Remove in v4.1. Use ParamList().")]]
TypeList* ArgTypes() const { return arg_types.get(); }
const zeek::IntrusivePtr<TypeList>& ParamList() const
const TypeListPtr& ParamList() const
{ return arg_types; }
void Describe(ODesc* d) const override;
@ -549,22 +571,22 @@ public:
{ return prototypes; }
protected:
friend zeek::IntrusivePtr<FuncType> zeek::make_intrusive<FuncType>();
friend FuncTypePtr zeek::make_intrusive<FuncType>();
FuncType() : Type(TYPE_FUNC) { flavor = FUNC_FLAVOR_FUNCTION; }
zeek::IntrusivePtr<RecordType> args;
zeek::IntrusivePtr<TypeList> arg_types;
zeek::IntrusivePtr<Type> yield;
RecordTypePtr args;
TypeListPtr arg_types;
TypePtr yield;
FunctionFlavor flavor;
std::vector<Prototype> prototypes;
};
class TypeType final : public Type {
public:
explicit TypeType(zeek::IntrusivePtr<Type> t) : zeek::Type(TYPE_TYPE), type(std::move(t)) {}
zeek::IntrusivePtr<Type> ShallowClone() override { return zeek::make_intrusive<TypeType>(type); }
explicit TypeType(TypePtr t) : zeek::Type(TYPE_TYPE), type(std::move(t)) {}
TypePtr ShallowClone() override { return zeek::make_intrusive<TypeType>(type); }
const zeek::IntrusivePtr<Type>& GetType() const
const TypePtr& GetType() const
{ return type; }
template <class T>
@ -577,24 +599,23 @@ public:
const zeek::Type* Type() const { return type.get(); }
protected:
zeek::IntrusivePtr<zeek::Type> type;
TypePtr type;
};
class TypeDecl final {
public:
TypeDecl() = default;
TypeDecl(const char* i, zeek::IntrusivePtr<Type> t,
zeek::IntrusivePtr<zeek::detail::Attributes> attrs = nullptr);
TypeDecl(const char* i, TypePtr t, zeek::detail::AttributesPtr attrs = nullptr);
TypeDecl(const TypeDecl& other);
~TypeDecl();
const zeek::IntrusivePtr<zeek::detail::Attr>& GetAttr(zeek::detail::AttrTag a) const
const zeek::detail::AttrPtr& GetAttr(zeek::detail::AttrTag a) const
{ return attrs ? attrs->Find(a) : zeek::detail::Attr::nil; }
void DescribeReST(ODesc* d, bool roles_only = false) const;
zeek::IntrusivePtr<Type> type;
zeek::IntrusivePtr<zeek::detail::Attributes> attrs;
TypePtr type;
zeek::detail::AttributesPtr attrs;
const char* id = nullptr;
};
@ -603,7 +624,7 @@ using type_decl_list = PList<TypeDecl>;
class RecordType final : public Type {
public:
explicit RecordType(type_decl_list* types);
zeek::IntrusivePtr<Type> ShallowClone() override;
TypePtr ShallowClone() override;
~RecordType() override;
@ -624,7 +645,7 @@ public:
* Looks up a field by name and returns its type. No check for invalid
* field name is performed.
*/
const zeek::IntrusivePtr<Type>& GetFieldType(const char* field_name) const
const TypePtr& GetFieldType(const char* field_name) const
{ return GetFieldType(FieldOffset(field_name)); }
/**
@ -639,7 +660,7 @@ public:
* Looks up a field by its index and returns its type. No check for
* invalid field offset is performed.
*/
const zeek::IntrusivePtr<Type>& GetFieldType(int field_index) const
const TypePtr& GetFieldType(int field_index) const
{ return (*types)[field_index]->type; }
/**
@ -650,7 +671,7 @@ public:
zeek::IntrusivePtr<T> GetFieldType(int field_index) const
{ return zeek::cast_intrusive<T>((*types)[field_index]->type); }
zeek::IntrusivePtr<Val> 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.
@ -672,7 +693,7 @@ public:
* @param rv an optional record value, if given the values of
* all fields will be provided in the returned table.
*/
zeek::IntrusivePtr<TableVal> GetRecordFieldsVal(const 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,
@ -712,23 +733,23 @@ public:
class FileType final : public Type {
public:
explicit FileType(zeek::IntrusivePtr<Type> yield_type);
zeek::IntrusivePtr<Type> ShallowClone() override { return zeek::make_intrusive<FileType>(yield); }
explicit FileType(TypePtr yield_type);
TypePtr ShallowClone() override { return zeek::make_intrusive<FileType>(yield); }
~FileType() override;
const zeek::IntrusivePtr<Type>& Yield() const override
const TypePtr& Yield() const override
{ return yield; }
void Describe(ODesc* d) const override;
protected:
zeek::IntrusivePtr<Type> yield;
TypePtr yield;
};
class OpaqueType final : public Type {
public:
explicit OpaqueType(const std::string& name);
zeek::IntrusivePtr<Type> ShallowClone() override { return zeek::make_intrusive<OpaqueType>(name); }
TypePtr ShallowClone() override { return zeek::make_intrusive<OpaqueType>(name); }
~OpaqueType() override { };
const std::string& Name() const { return name; }
@ -748,7 +769,7 @@ public:
explicit EnumType(const EnumType* e);
explicit EnumType(const std::string& arg_name);
zeek::IntrusivePtr<Type> ShallowClone() override;
TypePtr ShallowClone() override;
~EnumType() override;
// The value of this name is next internal counter value, starting
@ -770,7 +791,7 @@ public:
void DescribeReST(ODesc* d, bool roles_only = false) const override;
const zeek::IntrusivePtr<EnumVal>& GetVal(bro_int_t i);
const EnumValPtr& GetVal(bro_int_t i);
protected:
void AddNameInternal(const std::string& module_name,
@ -783,7 +804,7 @@ protected:
typedef std::map<std::string, bro_int_t> NameMap;
NameMap names;
using ValMap = std::unordered_map<bro_int_t, zeek::IntrusivePtr<EnumVal>>;
using ValMap = std::unordered_map<bro_int_t, EnumValPtr>;
ValMap vals;
// The counter is initialized to 0 and incremented on every implicit
@ -797,11 +818,11 @@ protected:
class VectorType final : public Type {
public:
explicit VectorType(zeek::IntrusivePtr<Type> t);
zeek::IntrusivePtr<Type> ShallowClone() override;
explicit VectorType(TypePtr t);
TypePtr ShallowClone() override;
~VectorType() override;
const zeek::IntrusivePtr<Type>& Yield() const override;
const TypePtr& Yield() const override;
int MatchesIndex(zeek::detail::ListExpr* index) const override;
@ -813,7 +834,7 @@ public:
void DescribeReST(ODesc* d, bool roles_only = false) const override;
protected:
zeek::IntrusivePtr<Type> yield_type;
TypePtr yield_type;
};
// True if the two types are equivalent. If is_init is true then the test is
@ -821,16 +842,16 @@ protected:
// true then for record types the field names have to match, too.
extern bool same_type(const Type& t1, const Type& t2,
bool is_init=false, bool match_record_field_names=true);
inline bool same_type(const zeek::IntrusivePtr<Type>& t1, const zeek::IntrusivePtr<Type>& t2,
inline bool same_type(const TypePtr& t1, const TypePtr& t2,
bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const Type* t1, const Type* t2,
bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const zeek::IntrusivePtr<Type>& t1, const Type* t2,
inline bool same_type(const TypePtr& t1, const Type* t2,
bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const Type* t1, const zeek::IntrusivePtr<Type>& t2,
inline bool same_type(const Type* t1, const TypePtr& t2,
bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); }
@ -853,22 +874,21 @@ extern TypeTag max_type(TypeTag t1, TypeTag t2);
// Given two types, returns the "merge", in which promotable types
// are promoted to the maximum of the two. Returns nil (and generates
// an error message) if the types are incompatible.
zeek::IntrusivePtr<Type> merge_types(const zeek::IntrusivePtr<Type>& t1,
const zeek::IntrusivePtr<Type>& t2);
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.
zeek::IntrusivePtr<Type> merge_type_list(zeek::detail::ListExpr* elements);
TypePtr merge_type_list(zeek::detail::ListExpr* elements);
// Given an expression, infer its type when used for an initialization.
zeek::IntrusivePtr<Type> init_type(zeek::detail::Expr* init);
TypePtr init_type(zeek::detail::Expr* init);
// Returns true if argument is an atomic type.
bool is_atomic_type(const Type& t);
inline bool is_atomic_type(const Type* t)
{ return is_atomic_type(*t); }
inline bool is_atomic_type(const zeek::IntrusivePtr<Type>& t)
inline bool is_atomic_type(const TypePtr& t)
{ return is_atomic_type(*t); }
// True if the given type tag corresponds to type that can be assigned to.
@ -925,10 +945,10 @@ 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 zeek::IntrusivePtr<Type>& base_type(zeek::TypeTag tag);
const TypePtr& base_type(zeek::TypeTag tag);
// Returns the basic error type.
inline const zeek::IntrusivePtr<Type>& error_type() { return base_type(TYPE_ERROR); }
inline const TypePtr& error_type() { return base_type(TYPE_ERROR); }
} // namespace zeek
@ -938,16 +958,16 @@ inline const zeek::IntrusivePtr<Type>& error_type() { return base_type(TYP
inline zeek::Type* base_type_no_ref(zeek::TypeTag tag)
{ return zeek::base_type(tag).get(); }
extern zeek::IntrusivePtr<zeek::OpaqueType> md5_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> sha1_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> sha256_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> entropy_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> cardinality_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> topk_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> bloomfilter_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> x509_opaque_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> ocsp_resp_opaque_type;
extern zeek::IntrusivePtr<zeek::OpaqueType> paraglob_type;
extern zeek::OpaqueTypePtr md5_type;
extern zeek::OpaqueTypePtr sha1_type;
extern zeek::OpaqueTypePtr sha256_type;
extern zeek::OpaqueTypePtr entropy_type;
extern zeek::OpaqueTypePtr cardinality_type;
extern zeek::OpaqueTypePtr topk_type;
extern zeek::OpaqueTypePtr bloomfilter_type;
extern zeek::OpaqueTypePtr x509_opaque_type;
extern zeek::OpaqueTypePtr ocsp_resp_opaque_type;
extern zeek::OpaqueTypePtr paraglob_type;
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
using TypeList [[deprecated("Remove in v4.1. Use zeek::TypeList instead.")]] = zeek::TypeList;

196
src/Val.cc
View file

@ -45,13 +45,13 @@ using namespace std;
Val::Val(Func* f) : Val({zeek::NewRef{}, f})
{}
Val::Val(zeek::IntrusivePtr<Func> f)
Val::Val(FuncPtr f)
: val(f.release()), type(val.func_val->GetType())
{}
static const zeek::IntrusivePtr<zeek::FileType>& GetStringFileType() noexcept
static const zeek::FileTypePtr& GetStringFileType() noexcept
{
static zeek::IntrusivePtr<zeek::FileType> string_file_type
static auto string_file_type
= zeek::make_intrusive<zeek::FileType>(zeek::base_type(zeek::TYPE_STRING));
return string_file_type;
@ -60,7 +60,7 @@ static const zeek::IntrusivePtr<zeek::FileType>& GetStringFileType() noexcept
Val::Val(BroFile* f) : Val({zeek::AdoptRef{}, f})
{}
Val::Val(zeek::IntrusivePtr<BroFile> f)
Val::Val(BroFilePtr f)
: val(f.release()), type(GetStringFileType())
{
assert(val.file_val->GetType()->Tag() == zeek::TYPE_STRING);
@ -82,19 +82,19 @@ Val::~Val()
#endif
}
zeek::IntrusivePtr<Val> Val::CloneState::NewClone(Val* src, zeek::IntrusivePtr<Val> dst)
ValPtr Val::CloneState::NewClone(Val* src, ValPtr dst)
{
clones.insert(std::make_pair(src, dst.get()));
return dst;
}
zeek::IntrusivePtr<Val> Val::Clone()
ValPtr Val::Clone()
{
Val::CloneState state;
return Clone(&state);
}
zeek::IntrusivePtr<Val> Val::Clone(CloneState* state)
ValPtr Val::Clone(CloneState* state)
{
auto i = state->clones.find(this);
@ -109,7 +109,7 @@ zeek::IntrusivePtr<Val> Val::Clone(CloneState* state)
return c;
}
zeek::IntrusivePtr<Val> Val::DoClone(CloneState* state)
ValPtr Val::DoClone(CloneState* state)
{
switch ( type->InternalType() ) {
case zeek::TYPE_INTERNAL_INT:
@ -153,7 +153,7 @@ zeek::IntrusivePtr<Val> Val::DoClone(CloneState* state)
return nullptr;
}
zeek::IntrusivePtr<Func> Val::AsFuncPtr() const
FuncPtr Val::AsFuncPtr() const
{
CHECK_TAG(type->Tag(), zeek::TYPE_FUNC, "Val::Func", zeek::type_name)
return {zeek::NewRef{}, val.func_val};
@ -256,7 +256,7 @@ double Val::CoerceToDouble() const
return 0.0;
}
zeek::IntrusivePtr<Val> Val::SizeVal() const
ValPtr Val::SizeVal() const
{
switch ( type->InternalType() ) {
case zeek::TYPE_INTERNAL_INT:
@ -419,7 +419,7 @@ bool Val::WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type,
return false;
}
zeek::IntrusivePtr<TableVal> Val::GetRecordFields()
TableValPtr Val::GetRecordFields()
{
static auto record_field_table = zeek::id::find_type<zeek::TableType>("record_field_table");
auto t = GetType().get();
@ -656,7 +656,7 @@ static void BuildJSON(threading::formatter::JSON::NullDoubleWriter& writer, Val*
}
}
zeek::IntrusivePtr<StringVal> Val::ToJSON(bool only_loggable, RE_Matcher* re)
StringValPtr Val::ToJSON(bool only_loggable, RE_Matcher* re)
{
rapidjson::StringBuffer buffer;
threading::formatter::JSON::NullDoubleWriter writer(buffer);
@ -739,7 +739,7 @@ void IntervalVal::ValDescribe(ODesc* d) const
}
}
zeek::IntrusivePtr<Val> PortVal::SizeVal() const
ValPtr PortVal::SizeVal() const
{
return val_mgr->Int(val.uint_val);
}
@ -820,7 +820,7 @@ void PortVal::ValDescribe(ODesc* d) const
d->Add(Protocol());
}
zeek::IntrusivePtr<Val> PortVal::DoClone(CloneState* state)
ValPtr PortVal::DoClone(CloneState* state)
{
// Immutable.
return {zeek::NewRef{}, this};
@ -857,7 +857,7 @@ unsigned int AddrVal::MemoryAllocation() const
return padded_sizeof(*this) + val.addr_val->MemoryAllocation();
}
zeek::IntrusivePtr<Val> AddrVal::SizeVal() const
ValPtr AddrVal::SizeVal() const
{
if ( val.addr_val->GetFamily() == IPv4 )
return val_mgr->Count(32);
@ -865,7 +865,7 @@ zeek::IntrusivePtr<Val> AddrVal::SizeVal() const
return val_mgr->Count(128);
}
zeek::IntrusivePtr<Val> AddrVal::DoClone(CloneState* state)
ValPtr AddrVal::DoClone(CloneState* state)
{
// Immutable.
return {zeek::NewRef{}, this};
@ -917,7 +917,7 @@ unsigned int SubNetVal::MemoryAllocation() const
return padded_sizeof(*this) + val.subnet_val->MemoryAllocation();
}
zeek::IntrusivePtr<Val> SubNetVal::SizeVal() const
ValPtr SubNetVal::SizeVal() const
{
int retained = 128 - val.subnet_val->LengthIPv6();
return zeek::make_intrusive<DoubleVal>(pow(2.0, double(retained)));
@ -962,7 +962,7 @@ bool SubNetVal::Contains(const IPAddr& addr) const
return val.subnet_val->Contains(addr);
}
zeek::IntrusivePtr<Val> SubNetVal::DoClone(CloneState* state)
ValPtr SubNetVal::DoClone(CloneState* state)
{
// Immutable.
return {zeek::NewRef{}, this};
@ -986,7 +986,7 @@ StringVal::StringVal(const string& s) : StringVal(s.length(), s.data())
{
}
zeek::IntrusivePtr<Val> StringVal::SizeVal() const
ValPtr StringVal::SizeVal() const
{
return val_mgr->Count(val.string_val->Len());
}
@ -1033,7 +1033,7 @@ unsigned int StringVal::MemoryAllocation() const
return padded_sizeof(*this) + val.string_val->MemoryAllocation();
}
zeek::IntrusivePtr<StringVal> StringVal::Replace(
StringValPtr StringVal::Replace(
RE_Matcher* re, const BroString& repl, bool do_all)
{
const u_char* s = Bytes();
@ -1118,7 +1118,7 @@ zeek::IntrusivePtr<StringVal> StringVal::Replace(
return zeek::make_intrusive<StringVal>(new BroString(true, result, r - result));
}
zeek::IntrusivePtr<Val> StringVal::DoClone(CloneState* state)
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
@ -1176,7 +1176,7 @@ unsigned int PatternVal::MemoryAllocation() const
return padded_sizeof(*this) + val.re_val->MemoryAllocation();
}
zeek::IntrusivePtr<Val> PatternVal::DoClone(CloneState* state)
ValPtr PatternVal::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
@ -1197,7 +1197,7 @@ ListVal::~ListVal()
{
}
zeek::IntrusivePtr<Val> ListVal::SizeVal() const
ValPtr ListVal::SizeVal() const
{
return val_mgr->Count(vals.size());
}
@ -1217,7 +1217,7 @@ RE_Matcher* ListVal::BuildRE() const
return re;
}
void ListVal::Append(zeek::IntrusivePtr<Val> v)
void ListVal::Append(ValPtr v)
{
if ( type->AsTypeList()->IsPure() )
{
@ -1235,7 +1235,7 @@ void ListVal::Append(Val* v)
Append({zeek::AdoptRef{}, v});
}
zeek::IntrusivePtr<TableVal> ListVal::ToSetVal() const
TableValPtr ListVal::ToSetVal() const
{
if ( tag == zeek::TYPE_ANY )
Internal("conversion of heterogeneous list to set");
@ -1282,7 +1282,7 @@ void ListVal::Describe(ODesc* d) const
}
}
zeek::IntrusivePtr<Val> ListVal::DoClone(CloneState* state)
ValPtr ListVal::DoClone(CloneState* state)
{
auto lv = zeek::make_intrusive<ListVal>(tag);
lv->vals.reserve(vals.size());
@ -1336,7 +1336,7 @@ static void table_entry_val_delete_func(void* val)
delete tv;
}
static void find_nested_record_types(const zeek::IntrusivePtr<zeek::Type>& t, std::set<zeek::RecordType*>* found)
static void find_nested_record_types(const zeek::TypePtr& t, std::set<zeek::RecordType*>* found)
{
if ( ! t )
return;
@ -1376,7 +1376,7 @@ static void find_nested_record_types(const zeek::IntrusivePtr<zeek::Type>& t, st
}
}
TableVal::TableVal(zeek::IntrusivePtr<zeek::TableType> t, zeek::IntrusivePtr<zeek::detail::Attributes> a) : Val(t)
TableVal::TableVal(zeek::TableTypePtr t, zeek::detail::AttributesPtr a) : Val(t)
{
Init(std::move(t));
SetAttrs(std::move(a));
@ -1396,7 +1396,7 @@ TableVal::TableVal(zeek::IntrusivePtr<zeek::TableType> t, zeek::IntrusivePtr<zee
}
}
void TableVal::Init(zeek::IntrusivePtr<zeek::TableType> t)
void TableVal::Init(zeek::TableTypePtr t)
{
table_type = std::move(t);
expire_func = nullptr;
@ -1459,7 +1459,7 @@ int TableVal::RecursiveSize() const
return n;
}
void TableVal::SetAttrs(zeek::IntrusivePtr<zeek::detail::Attributes> a)
void TableVal::SetAttrs(zeek::detail::AttributesPtr a)
{
attrs = std::move(a);
@ -1507,7 +1507,7 @@ void TableVal::CheckExpireAttr(zeek::detail::AttrTag at)
}
}
bool TableVal::Assign(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val)
bool TableVal::Assign(ValPtr index, ValPtr new_val)
{
auto k = MakeHashKey(*index);
@ -1525,8 +1525,8 @@ bool TableVal::Assign(Val* index, Val* new_val)
return Assign({zeek::NewRef{}, index}, {zeek::AdoptRef{}, new_val});
}
bool TableVal::Assign(zeek::IntrusivePtr<Val> index, std::unique_ptr<HashKey> k,
zeek::IntrusivePtr<Val> new_val)
bool TableVal::Assign(ValPtr index, std::unique_ptr<HashKey> k,
ValPtr new_val)
{
bool is_set = table_type->IsSet();
@ -1576,7 +1576,7 @@ bool TableVal::Assign(Val* index, HashKey* k, Val* new_val)
return Assign({zeek::NewRef{}, index}, std::unique_ptr<HashKey>{k}, {zeek::AdoptRef{}, new_val});
}
zeek::IntrusivePtr<Val> TableVal::SizeVal() const
ValPtr TableVal::SizeVal() const
{
return val_mgr->Count(Size());
}
@ -1668,7 +1668,7 @@ bool TableVal::RemoveFrom(Val* val) const
return true;
}
zeek::IntrusivePtr<TableVal> TableVal::Intersection(const TableVal& tv) const
TableValPtr TableVal::Intersection(const TableVal& tv) const
{
auto result = zeek::make_intrusive<TableVal>(table_type);
@ -1753,7 +1753,7 @@ bool TableVal::IsSubsetOf(const TableVal& tv) const
return true;
}
bool TableVal::ExpandAndInit(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val)
bool TableVal::ExpandAndInit(ValPtr index, ValPtr new_val)
{
const auto& index_type = index->GetType();
@ -1805,7 +1805,7 @@ bool TableVal::ExpandAndInit(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<V
}
zeek::IntrusivePtr<Val> TableVal::Default(const zeek::IntrusivePtr<Val>& index)
ValPtr TableVal::Default(const ValPtr& index)
{
const auto& def_attr = GetAttr(zeek::detail::ATTR_DEFAULT);
@ -1870,7 +1870,7 @@ zeek::IntrusivePtr<Val> TableVal::Default(const zeek::IntrusivePtr<Val>& index)
else
vl.emplace_back(index);
zeek::IntrusivePtr<Val> result;
ValPtr result;
try
{
@ -1889,7 +1889,7 @@ zeek::IntrusivePtr<Val> TableVal::Default(const zeek::IntrusivePtr<Val>& index)
return result;
}
const zeek::IntrusivePtr<Val>& TableVal::Find(const zeek::IntrusivePtr<Val>& index)
const ValPtr& TableVal::Find(const ValPtr& index)
{
if ( subnets )
{
@ -1934,7 +1934,7 @@ const zeek::IntrusivePtr<Val>& TableVal::Find(const zeek::IntrusivePtr<Val>& ind
return Val::nil;
}
zeek::IntrusivePtr<Val> TableVal::FindOrDefault(const zeek::IntrusivePtr<Val>& index)
ValPtr TableVal::FindOrDefault(const ValPtr& index)
{
if ( auto rval = Find(index) )
return rval;
@ -1944,9 +1944,9 @@ zeek::IntrusivePtr<Val> TableVal::FindOrDefault(const zeek::IntrusivePtr<Val>& i
Val* TableVal::Lookup(Val* index, bool use_default_val)
{
static zeek::IntrusivePtr<Val> last_default;
static ValPtr last_default;
last_default = nullptr;
zeek::IntrusivePtr<Val> idx{zeek::NewRef{}, index};
ValPtr idx{zeek::NewRef{}, index};
if ( const auto& rval = Find(idx) )
return rval.get();
@ -1958,7 +1958,7 @@ Val* TableVal::Lookup(Val* index, bool use_default_val)
return last_default.get();
}
zeek::IntrusivePtr<VectorVal> TableVal::LookupSubnets(const SubNetVal* search)
VectorValPtr TableVal::LookupSubnets(const SubNetVal* search)
{
if ( ! subnets )
reporter->InternalError("LookupSubnets called on wrong table type");
@ -1972,7 +1972,7 @@ zeek::IntrusivePtr<VectorVal> TableVal::LookupSubnets(const SubNetVal* search)
return result;
}
zeek::IntrusivePtr<TableVal> TableVal::LookupSubnetValues(const SubNetVal* search)
TableValPtr TableVal::LookupSubnetValues(const SubNetVal* search)
{
if ( ! subnets )
reporter->InternalError("LookupSubnetValues called on wrong table type");
@ -2024,13 +2024,13 @@ bool TableVal::UpdateTimestamp(Val* index)
return true;
}
zeek::IntrusivePtr<ListVal> TableVal::RecreateIndex(const HashKey& k) const
ListValPtr TableVal::RecreateIndex(const HashKey& k) const
{
return table_hash->RecoverVals(k);
}
void TableVal::CallChangeFunc(const Val* index,
const zeek::IntrusivePtr<Val>& old_value,
const ValPtr& old_value,
OnChangeType tpe)
{
if ( ! change_func || ! index || in_change_func )
@ -2092,11 +2092,11 @@ void TableVal::CallChangeFunc(const Val* index,
in_change_func = false;
}
zeek::IntrusivePtr<Val> TableVal::Remove(const Val& index)
ValPtr TableVal::Remove(const Val& index)
{
auto k = MakeHashKey(index);
TableEntryVal* v = k ? AsNonConstTable()->RemoveEntry(k.get()) : nullptr;
zeek::IntrusivePtr<Val> va;
ValPtr va;
if ( v )
va = v->GetVal() ? v->GetVal() : zeek::IntrusivePtr{zeek::NewRef{}, this};
@ -2114,10 +2114,10 @@ zeek::IntrusivePtr<Val> TableVal::Remove(const Val& index)
return va;
}
zeek::IntrusivePtr<Val> TableVal::Remove(const HashKey& k)
ValPtr TableVal::Remove(const HashKey& k)
{
TableEntryVal* v = AsNonConstTable()->RemoveEntry(k);
zeek::IntrusivePtr<Val> va;
ValPtr va;
if ( v )
va = v->GetVal() ? v->GetVal() : zeek::IntrusivePtr{zeek::NewRef{}, this};
@ -2143,7 +2143,7 @@ zeek::IntrusivePtr<Val> TableVal::Remove(const HashKey& k)
return va;
}
zeek::IntrusivePtr<ListVal> TableVal::ToListVal(zeek::TypeTag t) const
ListValPtr TableVal::ToListVal(zeek::TypeTag t) const
{
auto l = zeek::make_intrusive<ListVal>(t);
@ -2177,7 +2177,7 @@ ListVal* TableVal::ConvertToList(zeek::TypeTag t) const
return ToListVal().release();
}
zeek::IntrusivePtr<ListVal> TableVal::ToPureListVal() const
ListValPtr TableVal::ToPureListVal() const
{
const auto& tl = table_type->GetIndices()->GetTypes();
if ( tl.size() != 1 )
@ -2194,7 +2194,7 @@ ListVal* TableVal::ConvertToPureList() const
return ToPureListVal().release();
}
const zeek::IntrusivePtr<zeek::detail::Attr>& TableVal::GetAttr(zeek::detail::AttrTag t) const
const zeek::detail::AttrPtr& TableVal::GetAttr(zeek::detail::AttrTag t) const
{
return attrs ? attrs->Find(t) : zeek::detail::Attr::nil;
}
@ -2285,12 +2285,12 @@ void TableVal::Describe(ODesc* d) const
}
}
bool TableVal::ExpandCompoundAndInit(ListVal* lv, int k, zeek::IntrusivePtr<Val> new_val)
bool TableVal::ExpandCompoundAndInit(ListVal* lv, int k, ValPtr new_val)
{
Val* ind_k_v = lv->Idx(k).get();
auto ind_k = ind_k_v->GetType()->IsSet() ?
ind_k_v->AsTableVal()->ToListVal() :
zeek::IntrusivePtr<ListVal>{zeek::NewRef{}, ind_k_v->AsListVal()};
ListValPtr{zeek::NewRef{}, ind_k_v->AsListVal()};
for ( int i = 0; i < ind_k->Length(); ++i )
{
@ -2314,7 +2314,7 @@ bool TableVal::ExpandCompoundAndInit(ListVal* lv, int k, zeek::IntrusivePtr<Val>
return true;
}
bool TableVal::CheckAndAssign(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val)
bool TableVal::CheckAndAssign(ValPtr index, ValPtr new_val)
{
Val* v = nullptr;
if ( subnets )
@ -2397,7 +2397,7 @@ void TableVal::DoExpire(double t)
else if ( v->ExpireAccessTime() + timeout < t )
{
zeek::IntrusivePtr<ListVal> idx = nullptr;
ListValPtr idx = nullptr;
if ( expire_func )
{
@ -2491,7 +2491,7 @@ double TableVal::GetExpireTime()
return -1;
}
double TableVal::CallExpireFunc(zeek::IntrusivePtr<ListVal> idx)
double TableVal::CallExpireFunc(ListValPtr idx)
{
if ( ! expire_func )
return 0;
@ -2554,7 +2554,7 @@ double TableVal::CallExpireFunc(zeek::IntrusivePtr<ListVal> idx)
return secs;
}
zeek::IntrusivePtr<Val> TableVal::DoClone(CloneState* state)
ValPtr TableVal::DoClone(CloneState* state)
{
auto tv = zeek::make_intrusive<TableVal>(table_type);
state->NewClone(this, tv);
@ -2691,12 +2691,12 @@ RecordVal::RecordVal(zeek::RecordType* t, bool init_fields)
: RecordVal({zeek::NewRef{}, t}, init_fields)
{}
RecordVal::RecordVal(zeek::IntrusivePtr<zeek::RecordType> t, bool init_fields) : Val(std::move(t))
RecordVal::RecordVal(zeek::RecordTypePtr t, bool init_fields) : Val(std::move(t))
{
origin = nullptr;
auto rt = GetType()->AsRecordType();
int n = rt->NumFields();
auto vl = val.record_val = new std::vector<zeek::IntrusivePtr<Val>>;
auto vl = val.record_val = new std::vector<ValPtr>;
vl->reserve(n);
if ( is_parsing )
@ -2733,7 +2733,7 @@ RecordVal::RecordVal(zeek::IntrusivePtr<zeek::RecordType> t, bool init_fields) :
else if ( tag == zeek::TYPE_TABLE )
def = zeek::make_intrusive<TableVal>(zeek::IntrusivePtr{zeek::NewRef{}, type->AsTableType()},
zeek::IntrusivePtr{zeek::NewRef{}, a});
zeek::IntrusivePtr{zeek::NewRef{}, a});
else if ( tag == zeek::TYPE_VECTOR )
def = zeek::make_intrusive<VectorVal>(zeek::cast_intrusive<zeek::VectorType>(type));
@ -2748,12 +2748,12 @@ RecordVal::~RecordVal()
delete AsNonConstRecord();
}
zeek::IntrusivePtr<Val> RecordVal::SizeVal() const
ValPtr RecordVal::SizeVal() const
{
return val_mgr->Count(GetType()->AsRecordType()->NumFields());
}
void RecordVal::Assign(int field, zeek::IntrusivePtr<Val> new_val)
void RecordVal::Assign(int field, ValPtr new_val)
{
(*AsNonConstRecord())[field] = std::move(new_val);
Modified();
@ -2764,7 +2764,7 @@ void RecordVal::Assign(int field, Val* new_val)
Assign(field, {zeek::AdoptRef{}, new_val});
}
zeek::IntrusivePtr<Val> RecordVal::GetFieldOrDefault(int field) const
ValPtr RecordVal::GetFieldOrDefault(int field) const
{
const auto& val = (*AsRecord())[field];
@ -2804,7 +2804,7 @@ void RecordVal::DoneParsing()
parse_time_records.clear();
}
const zeek::IntrusivePtr<Val>& RecordVal::GetField(const char* field) const
const ValPtr& RecordVal::GetField(const char* field) const
{
int idx = GetType()->AsRecordType()->FieldOffset(field);
@ -2814,7 +2814,7 @@ const zeek::IntrusivePtr<Val>& RecordVal::GetField(const char* field) const
return GetField(idx);
}
zeek::IntrusivePtr<Val> RecordVal::GetFieldOrDefault(const char* field) const
ValPtr RecordVal::GetFieldOrDefault(const char* field) const
{
int idx = GetType()->AsRecordType()->FieldOffset(field);
@ -2824,10 +2824,9 @@ zeek::IntrusivePtr<Val> RecordVal::GetFieldOrDefault(const char* field) const
return GetFieldOrDefault(idx);
}
zeek::IntrusivePtr<RecordVal> RecordVal::CoerceTo(
zeek::IntrusivePtr<zeek::RecordType> t,
zeek::IntrusivePtr<RecordVal> aggr,
bool allow_orphaning) const
RecordValPtr RecordVal::CoerceTo(zeek::RecordTypePtr t,
RecordValPtr aggr,
bool allow_orphaning) const
{
if ( ! record_promotion_compatible(t.get(), GetType()->AsRecordType()) )
return nullptr;
@ -2889,8 +2888,7 @@ zeek::IntrusivePtr<RecordVal> RecordVal::CoerceTo(
return aggr;
}
zeek::IntrusivePtr<RecordVal> RecordVal::CoerceTo(zeek::IntrusivePtr<zeek::RecordType> t,
bool allow_orphaning)
RecordValPtr RecordVal::CoerceTo(zeek::RecordTypePtr t, bool allow_orphaning)
{
if ( same_type(GetType(), t) )
return {zeek::NewRef{}, this};
@ -2898,7 +2896,7 @@ zeek::IntrusivePtr<RecordVal> RecordVal::CoerceTo(zeek::IntrusivePtr<zeek::Recor
return CoerceTo(std::move(t), nullptr, allow_orphaning);
}
zeek::IntrusivePtr<TableVal> RecordVal::GetRecordFieldsVal() const
TableValPtr RecordVal::GetRecordFieldsVal() const
{
return GetType()->AsRecordType()->GetRecordFieldsVal(this);
}
@ -2970,7 +2968,7 @@ void RecordVal::DescribeReST(ODesc* d) const
d->Add("}");
}
zeek::IntrusivePtr<Val> RecordVal::DoClone(CloneState* state)
ValPtr RecordVal::DoClone(CloneState* state)
{
// We set origin to 0 here. Origin only seems to be used for exactly one
// purpose - to find the connection record that is associated with a
@ -3001,12 +2999,12 @@ unsigned int RecordVal::MemoryAllocation() const
size += v->MemoryAllocation();
}
size += pad_size(vl.capacity() * sizeof(zeek::IntrusivePtr<Val>));
size += pad_size(vl.capacity() * sizeof(ValPtr));
size += padded_sizeof(vl);
return size + padded_sizeof(*this);
}
zeek::IntrusivePtr<Val> EnumVal::SizeVal() const
ValPtr EnumVal::SizeVal() const
{
return val_mgr->Int(val.int_val);
}
@ -3021,7 +3019,7 @@ void EnumVal::ValDescribe(ODesc* d) const
d->Add(ename);
}
zeek::IntrusivePtr<Val> EnumVal::DoClone(CloneState* state)
ValPtr EnumVal::DoClone(CloneState* state)
{
// Immutable.
return {zeek::NewRef{}, this};
@ -3030,9 +3028,9 @@ zeek::IntrusivePtr<Val> EnumVal::DoClone(CloneState* state)
VectorVal::VectorVal(zeek::VectorType* t) : VectorVal({zeek::NewRef{}, t})
{ }
VectorVal::VectorVal(zeek::IntrusivePtr<zeek::VectorType> t) : Val(std::move(t))
VectorVal::VectorVal(zeek::VectorTypePtr t) : Val(std::move(t))
{
val.vector_val = new vector<zeek::IntrusivePtr<Val>>();
val.vector_val = new vector<ValPtr>();
}
VectorVal::~VectorVal()
@ -3040,12 +3038,12 @@ VectorVal::~VectorVal()
delete val.vector_val;
}
zeek::IntrusivePtr<Val> VectorVal::SizeVal() const
ValPtr VectorVal::SizeVal() const
{
return val_mgr->Count(uint32_t(val.vector_val->size()));
}
bool VectorVal::Assign(unsigned int index, zeek::IntrusivePtr<Val> element)
bool VectorVal::Assign(unsigned int index, ValPtr element)
{
if ( element &&
! same_type(element->GetType(), GetType()->AsVectorType()->Yield(), false) )
@ -3061,7 +3059,7 @@ bool VectorVal::Assign(unsigned int index, zeek::IntrusivePtr<Val> element)
}
bool VectorVal::AssignRepeat(unsigned int index, unsigned int how_many,
zeek::IntrusivePtr<Val> element)
ValPtr element)
{
ResizeAtLeast(index + how_many);
@ -3072,7 +3070,7 @@ bool VectorVal::AssignRepeat(unsigned int index, unsigned int how_many,
return true;
}
bool VectorVal::Insert(unsigned int index, zeek::IntrusivePtr<Val> element)
bool VectorVal::Insert(unsigned int index, ValPtr element)
{
if ( element &&
! same_type(element->GetType(), GetType()->AsVectorType()->Yield(), false) )
@ -3080,7 +3078,7 @@ bool VectorVal::Insert(unsigned int index, zeek::IntrusivePtr<Val> element)
return false;
}
vector<zeek::IntrusivePtr<Val>>::iterator it;
vector<ValPtr>::iterator it;
if ( index < val.vector_val->size() )
it = std::next(val.vector_val->begin(), index);
@ -3129,7 +3127,7 @@ bool VectorVal::AddTo(Val* val, bool /* is_first_init */) const
return true;
}
const zeek::IntrusivePtr<Val>& VectorVal::At(unsigned int index) const
const ValPtr& VectorVal::At(unsigned int index) const
{
if ( index >= val.vector_val->size() )
return Val::nil;
@ -3154,7 +3152,7 @@ unsigned int VectorVal::ResizeAtLeast(unsigned int new_num_elements)
return Resize(new_num_elements);
}
zeek::IntrusivePtr<Val> VectorVal::DoClone(CloneState* state)
ValPtr VectorVal::DoClone(CloneState* state)
{
auto vv = zeek::make_intrusive<VectorVal>(GetType<zeek::VectorType>());
vv->val.vector_val->reserve(val.vector_val->size());
@ -3188,10 +3186,10 @@ void VectorVal::ValDescribe(ODesc* d) const
d->Add("]");
}
zeek::IntrusivePtr<Val> check_and_promote(zeek::IntrusivePtr<Val> v,
const zeek::Type* t,
bool is_init,
const Location* expr_location)
ValPtr check_and_promote(ValPtr v,
const zeek::Type* t,
bool is_init,
const Location* expr_location)
{
if ( ! v )
return nullptr;
@ -3248,7 +3246,7 @@ zeek::IntrusivePtr<Val> check_and_promote(zeek::IntrusivePtr<Val> v,
// Already has the right internal type.
return v;
zeek::IntrusivePtr<Val> promoted_v;
ValPtr promoted_v;
switch ( it ) {
case zeek::TYPE_INTERNAL_INT:
@ -3365,7 +3363,7 @@ void describe_vals(const val_list* vals, ODesc* d, int offset)
}
}
void describe_vals(const std::vector<zeek::IntrusivePtr<Val>>& vals,
void describe_vals(const std::vector<ValPtr>& vals,
ODesc* d, size_t offset)
{
if ( ! d->IsReadable() )
@ -3393,7 +3391,7 @@ void delete_vals(val_list* vals)
}
}
zeek::IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::Type* t)
ValPtr cast_value_to_type(Val* v, zeek::Type* t)
{
// Note: when changing this function, adapt all three of
// cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type().
@ -3464,17 +3462,17 @@ bool can_cast_value_to_type(const zeek::Type* s, zeek::Type* t)
return false;
}
zeek::IntrusivePtr<Val> Val::MakeBool(bool b)
ValPtr Val::MakeBool(bool b)
{
return zeek::IntrusivePtr{zeek::AdoptRef{}, new Val(bro_int_t(b), zeek::TYPE_BOOL)};
}
zeek::IntrusivePtr<Val> Val::MakeInt(bro_int_t i)
ValPtr Val::MakeInt(bro_int_t i)
{
return zeek::IntrusivePtr{zeek::AdoptRef{}, new Val(i, zeek::TYPE_INT)};
}
zeek::IntrusivePtr<Val> Val::MakeCount(bro_uint_t u)
ValPtr Val::MakeCount(bro_uint_t u)
{
return zeek::IntrusivePtr{zeek::AdoptRef{}, new Val(u, zeek::TYPE_COUNT)};
}
@ -3506,7 +3504,7 @@ StringVal* ValManager::GetEmptyString() const
return empty_string->Ref()->AsStringVal();
}
const zeek::IntrusivePtr<PortVal>& ValManager::Port(uint32_t port_num, TransportProto port_type) const
const PortValPtr& ValManager::Port(uint32_t port_num, TransportProto port_type) const
{
if ( port_num >= 65536 )
{
@ -3522,7 +3520,7 @@ PortVal* ValManager::GetPort(uint32_t port_num, TransportProto port_type) const
return Port(port_num, port_type)->Ref()->AsPortVal();
}
const zeek::IntrusivePtr<PortVal>& ValManager::Port(uint32_t port_num) const
const PortValPtr& ValManager::Port(uint32_t port_num) const
{
auto mask = port_num & PORT_SPACE_MASK;
port_num &= ~PORT_SPACE_MASK;

265
src/Val.h
View file

@ -34,6 +34,9 @@ class Func;
class BroFile;
class PrefixTable;
using BroFilePtr = zeek::IntrusivePtr<BroFile>;
using FuncPtr = zeek::IntrusivePtr<Func>;
class Val;
class PortVal;
class AddrVal;
@ -49,6 +52,16 @@ class OpaqueVal;
class VectorVal;
class TableEntryVal;
using AddrValPtr = zeek::IntrusivePtr<AddrVal>;
using EnumValPtr = zeek::IntrusivePtr<EnumVal>;
using ListValPtr = zeek::IntrusivePtr<ListVal>;
using PortValPtr = zeek::IntrusivePtr<PortVal>;
using RecordValPtr = zeek::IntrusivePtr<RecordVal>;
using StringValPtr = zeek::IntrusivePtr<StringVal>;
using TableValPtr = zeek::IntrusivePtr<TableVal>;
using ValPtr = zeek::IntrusivePtr<Val>;
using VectorValPtr = zeek::IntrusivePtr<VectorVal>;
class IPAddr;
class IPPrefix;
@ -77,8 +90,8 @@ union BroValUnion {
BroFile* file_val;
RE_Matcher* re_val;
PDict<TableEntryVal>* table_val;
std::vector<zeek::IntrusivePtr<Val>>* record_val;
std::vector<zeek::IntrusivePtr<Val>>* vector_val;
std::vector<ValPtr>* record_val;
std::vector<ValPtr>* vector_val;
BroValUnion() = default;
@ -115,7 +128,7 @@ union BroValUnion {
class Val : public BroObj {
public:
static inline const zeek::IntrusivePtr<Val> nil;
static inline const ValPtr nil;
[[deprecated("Remove in v4.1. Use IntervalVal(), TimeVal(), or DoubleVal() constructors.")]]
Val(double d, zeek::TypeTag t)
@ -124,16 +137,16 @@ public:
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit Val(Func* f);
explicit Val(zeek::IntrusivePtr<Func> f);
explicit Val(FuncPtr f);
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit Val(BroFile* f);
// Note, the file will be closed after this Val is destructed if there's
// no other remaining references.
explicit Val(zeek::IntrusivePtr<BroFile> f);
explicit Val(BroFilePtr f);
// Extra arg to differentiate from protected version.
Val(zeek::IntrusivePtr<zeek::Type> t, bool type_type)
Val(zeek::TypePtr t, bool type_type)
: type(zeek::make_intrusive<zeek::TypeType>(std::move(t)))
{}
@ -148,7 +161,7 @@ public:
~Val() override;
Val* Ref() { ::Ref(this); return this; }
zeek::IntrusivePtr<Val> Clone();
ValPtr Clone();
bool IsZero() const;
bool IsOne() const;
@ -163,7 +176,7 @@ public:
// Returns a new Val with the "size" of this Val. What constitutes
// size depends on the Val's type.
virtual zeek::IntrusivePtr<Val> SizeVal() const;
virtual ValPtr SizeVal() const;
// Bytes in total value object.
virtual unsigned int MemoryAllocation() const;
@ -182,7 +195,7 @@ public:
[[deprecated("Remove in v4.1. Use GetType().")]]
const zeek::Type* Type() const { return type.get(); }
const zeek::IntrusivePtr<zeek::Type>& GetType() const
const zeek::TypePtr& GetType() const
{ return type; }
template <class T>
@ -215,10 +228,10 @@ public:
CONST_ACCESSOR(zeek::TYPE_STRING, BroString*, string_val, AsString)
CONST_ACCESSOR(zeek::TYPE_FUNC, Func*, func_val, AsFunc)
CONST_ACCESSOR(zeek::TYPE_TABLE, PDict<TableEntryVal>*, table_val, AsTable)
CONST_ACCESSOR(zeek::TYPE_RECORD, std::vector<zeek::IntrusivePtr<Val>>*, record_val, AsRecord)
CONST_ACCESSOR(zeek::TYPE_RECORD, std::vector<ValPtr>*, record_val, AsRecord)
CONST_ACCESSOR(zeek::TYPE_FILE, BroFile*, file_val, AsFile)
CONST_ACCESSOR(zeek::TYPE_PATTERN, RE_Matcher*, re_val, AsPattern)
CONST_ACCESSOR(zeek::TYPE_VECTOR, std::vector<zeek::IntrusivePtr<Val>>*, vector_val, AsVector)
CONST_ACCESSOR(zeek::TYPE_VECTOR, std::vector<ValPtr>*, vector_val, AsVector)
const IPPrefix& AsSubNet() const
{
@ -252,9 +265,9 @@ public:
ACCESSOR(zeek::TYPE_FUNC, Func*, func_val, AsFunc)
ACCESSOR(zeek::TYPE_FILE, BroFile*, file_val, AsFile)
ACCESSOR(zeek::TYPE_PATTERN, RE_Matcher*, re_val, AsPattern)
ACCESSOR(zeek::TYPE_VECTOR, std::vector<zeek::IntrusivePtr<Val>>*, vector_val, AsVector)
ACCESSOR(zeek::TYPE_VECTOR, std::vector<ValPtr>*, vector_val, AsVector)
zeek::IntrusivePtr<Func> AsFuncPtr() const;
FuncPtr AsFuncPtr() const;
const IPPrefix& AsSubNet()
{
@ -328,9 +341,9 @@ public:
static bool WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val);
zeek::IntrusivePtr<TableVal> GetRecordFields();
TableValPtr GetRecordFields();
zeek::IntrusivePtr<StringVal> ToJSON(bool only_loggable=false, RE_Matcher* re=nullptr);
StringValPtr ToJSON(bool only_loggable=false, RE_Matcher* re=nullptr);
protected:
@ -344,9 +357,9 @@ protected:
virtual void ValDescribe(ODesc* d) const;
virtual void ValDescribeReST(ODesc* d) const;
static zeek::IntrusivePtr<Val> MakeBool(bool b);
static zeek::IntrusivePtr<Val> MakeInt(bro_int_t i);
static zeek::IntrusivePtr<Val> MakeCount(bro_uint_t u);
static ValPtr MakeBool(bool b);
static ValPtr MakeInt(bro_int_t i);
static ValPtr MakeCount(bro_uint_t u);
template<typename V>
Val(V&& v, zeek::TypeTag t) noexcept
@ -354,32 +367,32 @@ protected:
{}
template<typename V>
Val(V&& v, zeek::IntrusivePtr<zeek::Type> t) noexcept
Val(V&& v, zeek::TypePtr t) noexcept
: val(std::forward<V>(v)), type(std::move(t))
{}
explicit Val(zeek::IntrusivePtr<zeek::Type> t) noexcept
explicit Val(zeek::TypePtr t) noexcept
: type(std::move(t))
{}
ACCESSOR(zeek::TYPE_TABLE, PDict<TableEntryVal>*, table_val, AsNonConstTable)
ACCESSOR(zeek::TYPE_RECORD, std::vector<zeek::IntrusivePtr<Val>>*, record_val, AsNonConstRecord)
ACCESSOR(zeek::TYPE_RECORD, std::vector<ValPtr>*, record_val, AsNonConstRecord)
// For internal use by the Val::Clone() methods.
struct CloneState {
// Caches a cloned value for later reuse during the same
// cloning operation. For recursive types, call this *before*
// descending down.
zeek::IntrusivePtr<Val> NewClone(Val* src, zeek::IntrusivePtr<Val> dst);
ValPtr NewClone(Val* src, ValPtr dst);
std::unordered_map<Val*, Val*> clones;
};
zeek::IntrusivePtr<Val> Clone(CloneState* state);
virtual zeek::IntrusivePtr<Val> DoClone(CloneState* state);
ValPtr Clone(CloneState* state);
virtual ValPtr DoClone(CloneState* state);
BroValUnion val;
zeek::IntrusivePtr<zeek::Type> type;
zeek::TypePtr type;
#ifdef DEBUG
// For debugging, we keep the name of the ID to which a Val is bound.
@ -405,21 +418,21 @@ public:
inline Val* GetTrue() const
{ return b_true->Ref(); }
inline const zeek::IntrusivePtr<Val>& True() const
inline const ValPtr& True() const
{ return b_true; }
[[deprecated("Remove in v4.1. Use val_mgr->False() instead.")]]
inline Val* GetFalse() const
{ return b_false->Ref(); }
inline const zeek::IntrusivePtr<Val>& False() const
inline const ValPtr& False() const
{ return b_false; }
[[deprecated("Remove in v4.1. Use val_mgr->Bool() instead.")]]
inline Val* GetBool(bool b) const
{ return b ? b_true->Ref() : b_false->Ref(); }
inline const zeek::IntrusivePtr<Val>& Bool(bool b) const
inline const ValPtr& Bool(bool b) const
{ return b ? b_true : b_false; }
[[deprecated("Remove in v4.1. Use val_mgr->Int() instead.")]]
@ -429,7 +442,7 @@ public:
Val::MakeInt(i).release() : ints[i - PREALLOCATED_INT_LOWEST]->Ref();
}
inline zeek::IntrusivePtr<Val> Int(int64_t i) const
inline ValPtr Int(int64_t i) const
{
return i < PREALLOCATED_INT_LOWEST || i > PREALLOCATED_INT_HIGHEST ?
Val::MakeInt(i) : ints[i - PREALLOCATED_INT_LOWEST];
@ -441,7 +454,7 @@ public:
return i >= PREALLOCATED_COUNTS ? Val::MakeCount(i).release() : counts[i]->Ref();
}
inline zeek::IntrusivePtr<Val> Count(uint64_t i) const
inline ValPtr Count(uint64_t i) const
{
return i >= PREALLOCATED_COUNTS ? Val::MakeCount(i) : counts[i];
}
@ -449,7 +462,7 @@ public:
[[deprecated("Remove in v4.1. Use val_mgr->EmptyString() instead.")]]
StringVal* GetEmptyString() const;
inline const zeek::IntrusivePtr<StringVal>& EmptyString() const
inline const StringValPtr& EmptyString() const
{ return empty_string; }
// Port number given in host order.
@ -457,23 +470,23 @@ public:
PortVal* GetPort(uint32_t port_num, TransportProto port_type) const;
// Port number given in host order.
const zeek::IntrusivePtr<PortVal>& Port(uint32_t port_num, TransportProto port_type) const;
const PortValPtr& Port(uint32_t port_num, TransportProto port_type) const;
// Host-order port number already masked with port space protocol mask.
[[deprecated("Remove in v4.1. Use val_mgr->Port() instead.")]]
PortVal* GetPort(uint32_t port_num) const;
// Host-order port number already masked with port space protocol mask.
const zeek::IntrusivePtr<PortVal>& Port(uint32_t port_num) const;
const PortValPtr& Port(uint32_t port_num) const;
private:
std::array<std::array<zeek::IntrusivePtr<PortVal>, 65536>, NUM_PORT_SPACES> ports;
std::array<zeek::IntrusivePtr<Val>, PREALLOCATED_COUNTS> counts;
std::array<zeek::IntrusivePtr<Val>, PREALLOCATED_INTS> ints;
zeek::IntrusivePtr<StringVal> empty_string;
zeek::IntrusivePtr<Val> b_true;
zeek::IntrusivePtr<Val> b_false;
std::array<std::array<PortValPtr, 65536>, NUM_PORT_SPACES> ports;
std::array<ValPtr, PREALLOCATED_COUNTS> counts;
std::array<ValPtr, PREALLOCATED_INTS> ints;
StringValPtr empty_string;
ValPtr b_true;
ValPtr b_false;
};
extern ValManager* val_mgr;
@ -511,7 +524,7 @@ public:
class PortVal final : public Val {
public:
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
// Returns the port number in host order (not including the mask).
uint32_t Port() const;
@ -542,7 +555,7 @@ protected:
PortVal(uint32_t p);
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
class AddrVal final : public Val {
@ -551,7 +564,7 @@ public:
explicit AddrVal(const std::string& text);
~AddrVal() override;
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
// Constructor for address already in network order.
explicit AddrVal(uint32_t addr); // IPv4.
@ -561,7 +574,7 @@ public:
unsigned int MemoryAllocation() const override;
protected:
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
class SubNetVal final : public Val {
@ -574,7 +587,7 @@ public:
explicit SubNetVal(const IPPrefix& prefix);
~SubNetVal() override;
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
const IPAddr& Prefix() const;
int Width() const;
@ -586,7 +599,7 @@ public:
protected:
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
class StringVal final : public Val {
@ -596,7 +609,7 @@ public:
explicit StringVal(const std::string& s);
StringVal(int length, const char* s);
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
int Len();
const u_char* Bytes();
@ -612,7 +625,7 @@ public:
unsigned int MemoryAllocation() const override;
zeek::IntrusivePtr<StringVal> Replace(RE_Matcher* re, const BroString& repl,
StringValPtr Replace(RE_Matcher* re, const BroString& repl,
bool do_all);
[[deprecated("Remove in v4.1. Use Replace().")]]
@ -621,7 +634,7 @@ public:
protected:
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
class PatternVal final : public Val {
@ -637,7 +650,7 @@ public:
protected:
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
// ListVals are mainly used to index tables that have more than one
@ -650,11 +663,11 @@ public:
zeek::TypeTag BaseTag() const { return tag; }
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
int Length() const { return vals.size(); }
const zeek::IntrusivePtr<Val>& Idx(size_t i) const { return vals[i]; }
const ValPtr& Idx(size_t i) const { return vals[i]; }
[[deprecated("Remove in v4.1. Use Idx() instead")]]
Val* Index(const int n) { return vals[n].get(); }
@ -675,27 +688,27 @@ public:
* Appends a value to the list.
* @param v the value to append.
*/
void Append(zeek::IntrusivePtr<Val> v);
void Append(ValPtr v);
[[deprecated("Remove in v4.1. Use Append(IntrusivePtr) instead.")]]
void Append(Val* v);
// Returns a Set representation of the list (which must be homogeneous).
zeek::IntrusivePtr<TableVal> ToSetVal() const;
TableValPtr ToSetVal() const;
[[deprecated("Remove in v4.1. Use ToSetVal() instead.")]]
TableVal* ConvertToSet() const;
const std::vector<zeek::IntrusivePtr<Val>>& Vals() const { return vals; }
const std::vector<ValPtr>& Vals() const { return vals; }
void Describe(ODesc* d) const override;
unsigned int MemoryAllocation() const override;
protected:
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
std::vector<zeek::IntrusivePtr<Val>> vals;
std::vector<ValPtr> vals;
zeek::TypeTag tag;
};
@ -703,7 +716,7 @@ extern double bro_start_network_time;
class TableEntryVal {
public:
explicit TableEntryVal(zeek::IntrusivePtr<Val> v)
explicit TableEntryVal(ValPtr v)
: val(std::move(v))
{
expire_access_time =
@ -715,7 +728,7 @@ public:
[[deprecated("Remove in v4.1. Use GetVal().")]]
Val* Value() { return val.get(); }
const zeek::IntrusivePtr<Val>& GetVal() const
const ValPtr& GetVal() const
{ return val; }
// Returns/sets time of last expiration relevant access to this value.
@ -727,7 +740,7 @@ public:
protected:
friend class TableVal;
zeek::IntrusivePtr<Val> val;
ValPtr val;
// The next entry stores seconds since Bro's start. We use ints here
// to save a few bytes, as we do not need a high resolution for these
@ -754,7 +767,7 @@ class Frame;
class TableVal final : public Val, public notifier::Modifiable {
public:
explicit TableVal(zeek::IntrusivePtr<zeek::TableType> t, zeek::IntrusivePtr<zeek::detail::Attributes> attrs = nullptr);
explicit TableVal(zeek::TableTypePtr t, zeek::detail::AttributesPtr attrs = nullptr);
[[deprecated("Remove in v4.1. Construct from IntrusivePtrs instead.")]]
explicit TableVal(zeek::TableType* t, zeek::detail::Attributes* attrs = nullptr)
@ -771,7 +784,7 @@ public:
* must be nullptr.
* @return True if the assignment type-checked.
*/
bool Assign(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val);
bool Assign(ValPtr index, ValPtr new_val);
/**
* Assigns a value at an associated index in the table (or in the
@ -783,8 +796,8 @@ public:
* must be nullptr.
* @return True if the assignment type-checked.
*/
bool Assign(zeek::IntrusivePtr<Val> index, std::unique_ptr<HashKey> k,
zeek::IntrusivePtr<Val> new_val);
bool Assign(ValPtr index, std::unique_ptr<HashKey> k,
ValPtr new_val);
// Returns true if the assignment typechecked, false if not. The
// methods take ownership of new_val, but not of the index. If we're
@ -797,7 +810,7 @@ public:
[[deprecated("Remove in v4.1. Use IntrusivePtr overload instead.")]]
bool Assign(Val* index, HashKey* k, Val* new_val);
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
// Add the entire contents of the table to the given value,
// which must also be a TableVal.
@ -825,7 +838,7 @@ public:
* @param v The intersecting table.
* @return The intersection of this table and the given one.
*/
zeek::IntrusivePtr<TableVal> Intersection(const TableVal& v) const;
TableValPtr Intersection(const TableVal& v) const;
[[deprecated("Remove in v4.1. Use Intersection() instead.")]]
TableVal* Intersect(const TableVal* v) const
@ -851,7 +864,7 @@ public:
// Expands any lists in the index into multiple initializations.
// Returns true if the initializations typecheck, false if not.
bool ExpandAndInit(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val);
bool ExpandAndInit(ValPtr index, ValPtr new_val);
/**
* Finds an index in the table and returns its associated value.
@ -862,7 +875,7 @@ public:
* non-existent index (nullptr), but otherwise has no meaning in relation
* to the set's contents.
*/
const zeek::IntrusivePtr<Val>& Find(const zeek::IntrusivePtr<Val>& index);
const ValPtr& Find(const ValPtr& index);
/**
* Finds an index in the table and returns its associated value or else
@ -872,7 +885,7 @@ public:
* exist, instead returns the &default value. If there's no &default
* attribute, then nullptr is still returned for non-existent index.
*/
zeek::IntrusivePtr<Val> FindOrDefault(const zeek::IntrusivePtr<Val>& index);
ValPtr FindOrDefault(const ValPtr& index);
// Returns the element's value if it exists in the table,
// nil otherwise. Note, "index" is not const because we
@ -883,12 +896,12 @@ public:
// For a table[subnet]/set[subnet], return all subnets that cover
// the given subnet.
// Causes an internal error if called for any other kind of table.
zeek::IntrusivePtr<VectorVal> LookupSubnets(const SubNetVal* s);
VectorValPtr LookupSubnets(const SubNetVal* s);
// For a set[subnet]/table[subnet], return a new table that only contains
// entries that cover the given subnet.
// Causes an internal error if called for any other kind of table.
zeek::IntrusivePtr<TableVal> LookupSubnetValues(const SubNetVal* s);
TableValPtr LookupSubnetValues(const SubNetVal* s);
// Sets the timestamp for the given index to network time.
// Returns false if index does not exist.
@ -897,7 +910,7 @@ public:
/**
* @return The index corresponding to the given HashKey.
*/
zeek::IntrusivePtr<ListVal> RecreateIndex(const HashKey& k) const;
ListValPtr RecreateIndex(const HashKey& k) const;
[[deprecated("Remove in v4.1. Use RecreateIndex().")]]
ListVal* RecoverIndex(const HashKey* k) const
@ -911,14 +924,14 @@ public:
* value is returned to differentiate it from non-existent index (nullptr),
* but otherwise has no meaning in relation to the set's contents.
*/
zeek::IntrusivePtr<Val> Remove(const Val& index);
ValPtr Remove(const Val& index);
/**
* Same as Remove(const Val&), but uses a precomputed hash key.
* @param k The hash key to lookup.
* @return Same as Remove(const Val&).
*/
zeek::IntrusivePtr<Val> Remove(const HashKey& k);
ValPtr Remove(const HashKey& k);
[[deprecated("Remove in v4.1. Use Remove().")]]
Val* Delete(const Val* index)
@ -929,25 +942,25 @@ public:
{ return Remove(*k).release(); }
// Returns a ListVal representation of the table (which must be a set).
zeek::IntrusivePtr<ListVal> ToListVal(zeek::TypeTag t = zeek::TYPE_ANY) const;
ListValPtr ToListVal(zeek::TypeTag t = zeek::TYPE_ANY) const;
// Returns a ListVal representation of the table (which must be a set
// with non-composite index type).
zeek::IntrusivePtr<ListVal> ToPureListVal() const;
ListValPtr ToPureListVal() const;
[[deprecated("Remove in v4.1. Use ToListVal() instead.")]]
ListVal* ConvertToList(zeek::TypeTag t=zeek::TYPE_ANY) const;
[[deprecated("Remove in v4.1. Use ToPureListVal() instead.")]]
ListVal* ConvertToPureList() const; // must be single index type
void SetAttrs(zeek::IntrusivePtr<zeek::detail::Attributes> attrs);
void SetAttrs(zeek::detail::AttributesPtr attrs);
const zeek::IntrusivePtr<zeek::detail::Attr>& GetAttr(zeek::detail::AttrTag t) const;
const zeek::detail::AttrPtr& GetAttr(zeek::detail::AttrTag t) const;
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
zeek::detail::Attributes* Attrs() { return attrs.get(); }
const zeek::IntrusivePtr<zeek::detail::Attributes>& GetAttrs() const
const zeek::detail::AttributesPtr& GetAttrs() const
{ return attrs; }
// Returns the size of the table.
@ -1003,22 +1016,22 @@ public:
static void DoneParsing();
protected:
void Init(zeek::IntrusivePtr<zeek::TableType> t);
void Init(zeek::TableTypePtr t);
using TableRecordDependencies = std::unordered_map<zeek::RecordType*, std::vector<zeek::IntrusivePtr<TableVal>>>;
using TableRecordDependencies = std::unordered_map<zeek::RecordType*, std::vector<TableValPtr>>;
using ParseTimeTableState = std::vector<std::pair<zeek::IntrusivePtr<Val>, zeek::IntrusivePtr<Val>>>;
using ParseTimeTableState = std::vector<std::pair<ValPtr, ValPtr>>;
using ParseTimeTableStates = std::unordered_map<TableVal*, ParseTimeTableState>;
ParseTimeTableState DumpTableState();
void RebuildTable(ParseTimeTableState ptts);
void CheckExpireAttr(zeek::detail::AttrTag at);
bool ExpandCompoundAndInit(ListVal* lv, int k, zeek::IntrusivePtr<Val> new_val);
bool CheckAndAssign(zeek::IntrusivePtr<Val> index, zeek::IntrusivePtr<Val> new_val);
bool ExpandCompoundAndInit(ListVal* lv, int k, ValPtr new_val);
bool CheckAndAssign(ValPtr index, ValPtr new_val);
// Calculates default value for index. Returns nullptr if none.
zeek::IntrusivePtr<Val> Default(const zeek::IntrusivePtr<Val>& index);
ValPtr Default(const ValPtr& index);
// Returns true if item expiration is enabled.
bool ExpirationEnabled() { return expire_time != nullptr; }
@ -1029,27 +1042,27 @@ protected:
double GetExpireTime();
// Calls &expire_func and returns its return interval;
double CallExpireFunc(zeek::IntrusivePtr<ListVal> idx);
double CallExpireFunc(ListValPtr idx);
// Enum for the different kinds of changes an &on_change handler can see
enum OnChangeType { ELEMENT_NEW, ELEMENT_CHANGED, ELEMENT_REMOVED, ELEMENT_EXPIRED };
// Calls &change_func. Does not take ownership of values. (Refs if needed).
void CallChangeFunc(const Val* index, const zeek::IntrusivePtr<Val>& old_value,
void CallChangeFunc(const Val* index, const ValPtr& old_value,
OnChangeType tpe);
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
zeek::IntrusivePtr<zeek::TableType> table_type;
zeek::TableTypePtr table_type;
CompositeHash* table_hash;
zeek::IntrusivePtr<zeek::detail::Attributes> attrs;
zeek::IntrusivePtr<zeek::detail::Expr> expire_time;
zeek::IntrusivePtr<zeek::detail::Expr> expire_func;
zeek::detail::AttributesPtr attrs;
zeek::detail::ExprPtr expire_time;
zeek::detail::ExprPtr expire_func;
TableValTimer* timer;
IterCookie* expire_cookie;
PrefixTable* subnets;
zeek::IntrusivePtr<Val> def_val;
zeek::IntrusivePtr<zeek::detail::Expr> change_func;
ValPtr def_val;
zeek::detail::ExprPtr change_func;
// prevent recursion of change functions
bool in_change_func = false;
@ -1061,18 +1074,18 @@ class RecordVal final : public Val, public notifier::Modifiable {
public:
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit RecordVal(zeek::RecordType* t, bool init_fields = true);
explicit RecordVal(zeek::IntrusivePtr<zeek::RecordType> t, bool init_fields = true);
explicit RecordVal(zeek::RecordTypePtr t, bool init_fields = true);
~RecordVal() override;
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
/**
* Assign a value to a record field.
* @param field The field index to assign.
* @param new_val The value to assign.
*/
void Assign(int field, zeek::IntrusivePtr<Val> new_val);
void Assign(int field, ValPtr new_val);
/**
* Assign a value of type @c T to a record field, as constructed from
@ -1089,7 +1102,7 @@ public:
void Assign(int field, Val* new_val);
// Note: the following nullptr method can also go upon removing the above.
void Assign(int field, std::nullptr_t)
{ Assign(field, zeek::IntrusivePtr<Val>{}); }
{ Assign(field, ValPtr{}); }
[[deprecated("Remove in v4.1. Use GetField().")]]
Val* Lookup(int field) const // Does not Ref() value.
@ -1100,7 +1113,7 @@ public:
* @param field The field index to retrieve.
* @return The value at the given field index.
*/
const zeek::IntrusivePtr<Val>& GetField(int field) const
const ValPtr& GetField(int field) const
{ return (*AsRecord())[field]; }
/**
@ -1120,7 +1133,7 @@ public:
* @return The value at the given field index or the default value if
* the field hasn't been assigned yet.
*/
zeek::IntrusivePtr<Val> GetFieldOrDefault(int field) const;
ValPtr GetFieldOrDefault(int field) const;
[[deprecated("Remove in v4.1. Use GetFieldOrDefault().")]]
Val* LookupWithDefault(int field) const
@ -1132,7 +1145,7 @@ public:
* @return The value of the given field. If no such field name exists,
* a fatal error occurs.
*/
const zeek::IntrusivePtr<Val>& GetField(const char* field) const;
const ValPtr& GetField(const char* field) const;
/**
* Returns the value of a given field name as cast to type @c T.
@ -1153,7 +1166,7 @@ public:
* if the field hasn't been assigned yet. If no such field name exists,
* a fatal error occurs.
*/
zeek::IntrusivePtr<Val> GetFieldOrDefault(const char* field) const;
ValPtr GetFieldOrDefault(const char* field) const;
/**
* Returns the value of a given field name or its default value
@ -1183,7 +1196,7 @@ public:
/**
* Returns a "record_field_table" value for introspection purposes.
*/
zeek::IntrusivePtr<TableVal> GetRecordFieldsVal() const;
TableValPtr GetRecordFieldsVal() const;
// This is an experiment to associate a BroObj within the
// event engine to a record value in bro script.
@ -1201,13 +1214,11 @@ public:
//
// The *allow_orphaning* parameter allows for a record to be demoted
// down to a record type that contains less fields.
zeek::IntrusivePtr<RecordVal> CoerceTo(
zeek::IntrusivePtr<zeek::RecordType> other,
zeek::IntrusivePtr<RecordVal> aggr,
bool allow_orphaning = false) const;
zeek::IntrusivePtr<RecordVal> CoerceTo(
zeek::IntrusivePtr<zeek::RecordType> other,
bool allow_orphaning = false);
RecordValPtr CoerceTo(zeek::RecordTypePtr other,
RecordValPtr aggr,
bool allow_orphaning = false) const;
RecordValPtr CoerceTo(zeek::RecordTypePtr other,
bool allow_orphaning = false);
unsigned int MemoryAllocation() const override;
void DescribeReST(ODesc* d) const override;
@ -1222,17 +1233,17 @@ public:
static void DoneParsing();
protected:
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
BroObj* origin;
using RecordTypeValMap = std::unordered_map<zeek::RecordType*, std::vector<zeek::IntrusivePtr<RecordVal>>>;
using RecordTypeValMap = std::unordered_map<zeek::RecordType*, std::vector<RecordValPtr>>;
static RecordTypeValMap parse_time_records;
};
class EnumVal final : public Val {
public:
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
protected:
friend class Val;
@ -1241,11 +1252,11 @@ protected:
template<class T, class... Ts>
friend zeek::IntrusivePtr<T> zeek::make_intrusive(Ts&&... args);
EnumVal(zeek::IntrusivePtr<zeek::EnumType> t, int i) : Val(bro_int_t(i), std::move(t))
EnumVal(zeek::EnumTypePtr t, int i) : Val(bro_int_t(i), std::move(t))
{}
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
@ -1253,10 +1264,10 @@ class VectorVal final : public Val, public notifier::Modifiable {
public:
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit VectorVal(zeek::VectorType* t);
explicit VectorVal(zeek::IntrusivePtr<zeek::VectorType> t);
explicit VectorVal(zeek::VectorTypePtr t);
~VectorVal() override;
zeek::IntrusivePtr<Val> SizeVal() const override;
ValPtr SizeVal() const override;
/**
* Assigns an element to a given vector index.
@ -1265,7 +1276,7 @@ public:
* @return True if the element was successfully assigned, or false if
* the element was the wrong type.
*/
bool Assign(unsigned int index, zeek::IntrusivePtr<Val> element);
bool Assign(unsigned int index, ValPtr element);
// Note: does NOT Ref() the element! Remember to do so unless
// the element was just created and thus has refcount 1.
@ -1274,7 +1285,7 @@ public:
{ return Assign(index, {zeek::AdoptRef{}, element}); }
// Note: the following nullptr method can also go upon removing the above.
void Assign(unsigned int index, std::nullptr_t)
{ Assign(index, zeek::IntrusivePtr<Val>{}); }
{ Assign(index, ValPtr{}); }
[[deprecated("Remove in v4.1. Assign using integer index and IntrusivePtr element.")]]
bool Assign(Val* index, Val* element)
@ -1291,7 +1302,7 @@ public:
* the element was the wrong type.
*/
bool AssignRepeat(unsigned int index, unsigned int how_many,
zeek::IntrusivePtr<Val> element);
ValPtr element);
[[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]]
bool AssignRepeat(unsigned int index, unsigned int how_many, Val* element)
@ -1307,7 +1318,7 @@ public:
* @return The element at the given index or nullptr if the index
* does not exist (it's greater than or equal to vector's current size).
*/
const zeek::IntrusivePtr<Val>& At(unsigned int index) const;
const ValPtr& At(unsigned int index) const;
[[deprecated("Remove in v4.1. Use At().")]]
Val* Lookup(unsigned int index) const
@ -1339,7 +1350,7 @@ public:
* @return True if the element was inserted or false if the element was
* the wrong type.
*/
bool Insert(unsigned int index, zeek::IntrusivePtr<Val> element);
bool Insert(unsigned int index, ValPtr element);
[[deprecated("Remove in v4.1. Insert an IntrusivePtr instead.")]]
bool Insert(unsigned int index, Val* element)
@ -1350,33 +1361,33 @@ public:
protected:
void ValDescribe(ODesc* d) const override;
zeek::IntrusivePtr<Val> DoClone(CloneState* state) override;
ValPtr DoClone(CloneState* state) override;
};
// Checks the given value for consistency with the given type. If an
// exact match, returns it. If promotable, returns the promoted version.
// 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 zeek::IntrusivePtr<Val> check_and_promote(
zeek::IntrusivePtr<Val> v, const zeek::Type* t, bool is_init,
extern ValPtr check_and_promote(
ValPtr v, const zeek::Type* t, bool is_init,
const 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);
extern bool is_atomic_val(const Val* v);
extern void describe_vals(const val_list* vals, ODesc* d, int offset=0);
extern void describe_vals(const std::vector<zeek::IntrusivePtr<Val>>& vals,
extern void describe_vals(const std::vector<ValPtr>& vals,
ODesc* d, size_t offset = 0);
extern void delete_vals(val_list* 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(const zeek::IntrusivePtr<Val>& v) { return is_vector(v.get()); }
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 zeek::IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::Type* t);
extern ValPtr cast_value_to_type(Val* v, zeek::Type* t);
// Returns true if v can be casted to type T. If so, check_and_cast() will
// succeed as well.

73
src/Var.cc
View file

@ -19,9 +19,9 @@
using namespace zeek::detail;
static zeek::IntrusivePtr<Val> init_val(zeek::detail::Expr* init,
const zeek::Type* t,
zeek::IntrusivePtr<Val> aggr)
static ValPtr init_val(zeek::detail::Expr* init,
const zeek::Type* t,
ValPtr aggr)
{
try
{
@ -33,9 +33,9 @@ static zeek::IntrusivePtr<Val> init_val(zeek::detail::Expr* init,
}
}
static bool add_prototype(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::Type* t,
std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>* attrs,
const zeek::IntrusivePtr<zeek::detail::Expr>& init)
static bool add_prototype(const zeek::detail::IDPtr& id, zeek::Type* t,
std::vector<AttrPtr>* attrs,
const zeek::detail::ExprPtr& init)
{
if ( ! zeek::IsFunc(id->GetType()->Tag()) )
return false;
@ -111,10 +111,10 @@ static bool add_prototype(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::
return true;
}
static void make_var(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::IntrusivePtr<zeek::Type> t,
static void make_var(const zeek::detail::IDPtr& id, zeek::TypePtr t,
zeek::detail::InitClass c,
zeek::IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr,
zeek::detail::ExprPtr init,
std::unique_ptr<std::vector<AttrPtr>> attr,
decl_type dt,
bool do_init)
{
@ -244,7 +244,7 @@ static void make_var(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::Intru
else if ( dt != VAR_REDEF || init || ! attr )
{
zeek::IntrusivePtr<Val> aggr;
ValPtr aggr;
if ( t->Tag() == zeek::TYPE_RECORD )
{
@ -264,7 +264,7 @@ static void make_var(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::Intru
else if ( t->Tag() == zeek::TYPE_VECTOR )
aggr = zeek::make_intrusive<VectorVal>(zeek::cast_intrusive<zeek::VectorType>(t));
zeek::IntrusivePtr<Val> v;
ValPtr v;
if ( init )
{
@ -306,24 +306,27 @@ static void make_var(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::Intru
// 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<zeek::IntrusivePtr<zeek::detail::ID>> inits;
std::vector<zeek::detail::IDPtr> inits;
auto f = zeek::make_intrusive<BroFunc>(id, nullptr, inits, 0, 0);
id->SetVal(zeek::make_intrusive<Val>(std::move(f)));
}
}
void add_global(const zeek::IntrusivePtr<zeek::detail::ID>& id, zeek::IntrusivePtr<zeek::Type> t,
zeek::detail::InitClass c, zeek::IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr,
decl_type dt)
void add_global(
const zeek::detail::IDPtr& id,
zeek::TypePtr t,
zeek::detail::InitClass c, zeek::detail::ExprPtr init,
std::unique_ptr<std::vector<AttrPtr>> attr,
decl_type dt)
{
make_var(id, std::move(t), c, std::move(init), std::move(attr), dt, true);
}
zeek::IntrusivePtr<zeek::detail::Stmt> add_local(zeek::IntrusivePtr<zeek::detail::ID> id, zeek::IntrusivePtr<zeek::Type> t,
zeek::detail::InitClass c, zeek::IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr,
decl_type dt)
zeek::detail::StmtPtr add_local(
zeek::detail::IDPtr id, zeek::TypePtr t,
zeek::detail::InitClass c, zeek::detail::ExprPtr init,
std::unique_ptr<std::vector<AttrPtr>> attr,
decl_type dt)
{
make_var(id, std::move(t), c, init, std::move(attr), dt, false);
@ -352,10 +355,10 @@ zeek::IntrusivePtr<zeek::detail::Stmt> add_local(zeek::IntrusivePtr<zeek::detail
}
}
extern zeek::IntrusivePtr<zeek::detail::Expr> add_and_assign_local(
zeek::IntrusivePtr<zeek::detail::ID> id,
zeek::IntrusivePtr<zeek::detail::Expr> init,
zeek::IntrusivePtr<Val> val)
extern zeek::detail::ExprPtr add_and_assign_local(
zeek::detail::IDPtr id,
zeek::detail::ExprPtr init,
ValPtr val)
{
make_var(id, nullptr, zeek::detail::INIT_FULL, init, nullptr, VAR_REGULAR, false);
auto name_expr = zeek::make_intrusive<zeek::detail::NameExpr>(std::move(id));
@ -363,12 +366,12 @@ extern zeek::IntrusivePtr<zeek::detail::Expr> add_and_assign_local(
std::move(name_expr), std::move(init), false, std::move(val));
}
void add_type(zeek::detail::ID* id, zeek::IntrusivePtr<zeek::Type> t,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr)
void add_type(zeek::detail::ID* id, zeek::TypePtr t,
std::unique_ptr<std::vector<AttrPtr>> attr)
{
std::string new_type_name = id->Name();
std::string old_type_name = t->GetName();
zeek::IntrusivePtr<zeek::Type> tnew;
zeek::TypePtr tnew;
if ( (t->Tag() == zeek::TYPE_RECORD || t->Tag() == zeek::TYPE_ENUM) &&
old_type_name.empty() )
@ -406,10 +409,10 @@ static void transfer_arg_defaults(zeek::RecordType* args, zeek::RecordType* recv
if ( ! recv_i->attrs )
{
std::vector<zeek::IntrusivePtr<zeek::detail::Attr>> a{def};
std::vector<AttrPtr> a{def};
recv_i->attrs = zeek::make_intrusive<zeek::detail::Attributes>(std::move(a),
recv_i->type,
true, false);
recv_i->type,
true, false);
}
else if ( ! recv_i->attrs->Find(zeek::detail::ATTR_DEFAULT) )
@ -417,7 +420,7 @@ static void transfer_arg_defaults(zeek::RecordType* args, zeek::RecordType* recv
}
}
static zeek::detail::Attr* find_attr(const std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>* al,
static zeek::detail::Attr* find_attr(const std::vector<AttrPtr>* al,
zeek::detail::AttrTag tag)
{
if ( ! al )
@ -465,10 +468,10 @@ static bool canonical_arg_types_match(const zeek::FuncType* decl, const zeek::Fu
return true;
}
void begin_func(zeek::IntrusivePtr<zeek::detail::ID> id, const char* module_name,
void begin_func(zeek::detail::IDPtr id, const char* module_name,
zeek::FunctionFlavor flavor, bool is_redef,
zeek::IntrusivePtr<zeek::FuncType> t,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attrs)
zeek::FuncTypePtr t,
std::unique_ptr<std::vector<AttrPtr>> attrs)
{
if ( flavor == zeek::FUNC_FLAVOR_EVENT )
{
@ -639,7 +642,7 @@ TraversalCode OuterIDBindingFinder::PostExpr(const zeek::detail::Expr* expr)
return TC_CONTINUE;
}
void end_func(zeek::IntrusivePtr<zeek::detail::Stmt> body)
void end_func(zeek::detail::StmtPtr body)
{
auto ingredients = std::make_unique<function_ingredients>(pop_scope(), std::move(body));

42
src/Var.h
View file

@ -16,37 +16,41 @@ ZEEK_FORWARD_DECLARE_NAMESPACED(FuncType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
namespace zeek::detail {
using StmtPtr = zeek::IntrusivePtr<zeek::detail::Stmt>;
}
typedef enum { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, } decl_type;
extern void add_global(const zeek::IntrusivePtr<zeek::detail::ID>& id,
zeek::IntrusivePtr<zeek::Type> t,
extern void add_global(const zeek::detail::IDPtr& id,
zeek::TypePtr t,
zeek::detail::InitClass c,
zeek::IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr,
zeek::detail::ExprPtr init,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attr,
decl_type dt);
extern zeek::IntrusivePtr<zeek::detail::Stmt> add_local(
zeek::IntrusivePtr<zeek::detail::ID> id,
zeek::IntrusivePtr<zeek::Type> t,
extern zeek::detail::StmtPtr add_local(
zeek::detail::IDPtr id,
zeek::TypePtr t,
zeek::detail::InitClass c,
zeek::IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr,
zeek::detail::ExprPtr init,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attr,
decl_type dt);
extern zeek::IntrusivePtr<zeek::detail::Expr> add_and_assign_local(
zeek::IntrusivePtr<zeek::detail::ID> id,
zeek::IntrusivePtr<zeek::detail::Expr> init,
zeek::IntrusivePtr<Val> val = nullptr);
extern zeek::detail::ExprPtr add_and_assign_local(
zeek::detail::IDPtr id,
zeek::detail::ExprPtr init,
ValPtr val = nullptr);
extern void add_type(zeek::detail::ID* id, zeek::IntrusivePtr<zeek::Type> t,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attr);
extern void add_type(zeek::detail::ID* id, zeek::TypePtr t,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attr);
extern void begin_func(zeek::IntrusivePtr<zeek::detail::ID> id, const char* module_name,
extern void begin_func(zeek::detail::IDPtr id, const char* module_name,
zeek::FunctionFlavor flavor, bool is_redef,
zeek::IntrusivePtr<zeek::FuncType> t,
std::unique_ptr<std::vector<zeek::IntrusivePtr<zeek::detail::Attr>>> attrs = nullptr);
zeek::FuncTypePtr t,
std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs = nullptr);
extern void end_func(zeek::IntrusivePtr<zeek::detail::Stmt> body);
extern void end_func(zeek::detail::StmtPtr body);
// Gather all IDs referenced inside a body that aren't part of a given scope.
extern id_list gather_outer_ids(Scope* scope, zeek::detail::Stmt* body);

8
src/analyzer/Analyzer.cc
View file

@ -710,7 +710,7 @@ void Analyzer::ProtocolViolation(const char* reason, const char* data, int len)
if ( ! protocol_violation )
return;
zeek::IntrusivePtr<StringVal> r;
StringValPtr r;
if ( data && len )
{
@ -794,7 +794,7 @@ RecordVal* Analyzer::BuildConnVal()
return conn->ConnVal()->Ref()->AsRecordVal();
}
const zeek::IntrusivePtr<RecordVal>& Analyzer::ConnVal()
const RecordValPtr& Analyzer::ConnVal()
{
return conn->ConnVal();
}
@ -926,12 +926,12 @@ void TransportLayerAnalyzer::Done()
}
void TransportLayerAnalyzer::SetContentsFile(unsigned int /* direction */,
zeek::IntrusivePtr<BroFile> /* f */)
BroFilePtr /* f */)
{
reporter->Error("analyzer type does not support writing to a contents file");
}
zeek::IntrusivePtr<BroFile> TransportLayerAnalyzer::GetContentsFile(unsigned int /* direction */) const
BroFilePtr TransportLayerAnalyzer::GetContentsFile(unsigned int /* direction */) const
{
reporter->Error("analyzer type does not support writing to a contents file");
return nullptr;

12
src/analyzer/Analyzer.h
View file

@ -17,6 +17,8 @@
#include "../IntrusivePtr.h"
class BroFile;
using BroFilePtr = zeek::IntrusivePtr<BroFile>;
class Rule;
class Connection;
class IP_Hdr;
@ -35,6 +37,8 @@ using analyzer_list = std::list<Analyzer*>;
typedef uint32_t ID;
typedef void (Analyzer::*analyzer_timer_func)(double t);
using RecordValPtr = zeek::IntrusivePtr<RecordVal>;
/**
* Class to receive processed output from an anlyzer.
*/
@ -556,7 +560,7 @@ public:
* Convenience function that forwards directly to
* Connection::ConnVal().
*/
const zeek::IntrusivePtr<RecordVal>& ConnVal();
const RecordValPtr& ConnVal();
/**
* Convenience function that forwards directly to the corresponding
@ -604,7 +608,7 @@ public:
template <class... Args>
std::enable_if_t<
std::is_convertible_v<
std::tuple_element_t<0, std::tuple<Args...>>, zeek::IntrusivePtr<Val>>>
std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>>
EnqueueConnEvent(EventHandlerPtr h, Args&&... args)
{ return EnqueueConnEvent(h, zeek::Args{std::forward<Args>(args)...}); }
@ -911,7 +915,7 @@ public:
* @param f The file to record to.
*
*/
virtual void SetContentsFile(unsigned int direction, zeek::IntrusivePtr<BroFile> f);
virtual void SetContentsFile(unsigned int direction, BroFilePtr f);
/**
* Returns an associated contents file, if any. This must only be
@ -921,7 +925,7 @@ public:
* @param direction One of the CONTENTS_* constants indicating which
* direction the query is for.
*/
virtual zeek::IntrusivePtr<BroFile> GetContentsFile(unsigned int direction) const;
virtual BroFilePtr GetContentsFile(unsigned int direction) const;
/**
* Associates a PIA with this analyzer. A PIA takes the

2
src/analyzer/Manager.cc
View file

@ -576,7 +576,7 @@ void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp,
void Manager::ScheduleAnalyzer(const IPAddr& orig, const IPAddr& resp, PortVal* resp_p,
Val* analyzer, double timeout)
{
zeek::IntrusivePtr<EnumVal> ev{zeek::NewRef{}, analyzer->AsEnumVal()};
EnumValPtr ev{zeek::NewRef{}, analyzer->AsEnumVal()};
return ScheduleAnalyzer(orig, resp, resp_p->Port(), resp_p->PortType(),
Tag(std::move(ev)), timeout);
}

4
src/analyzer/Tag.cc
View file

@ -16,7 +16,7 @@ analyzer::Tag& analyzer::Tag::operator=(const analyzer::Tag& other)
return *this;
}
const zeek::IntrusivePtr<EnumVal>& analyzer::Tag::AsVal() const
const EnumValPtr& analyzer::Tag::AsVal() const
{
return ::Tag::AsVal(analyzer_mgr->GetTagType());
}
@ -26,7 +26,7 @@ EnumVal* analyzer::Tag::AsEnumVal() const
return AsVal().get();
}
analyzer::Tag::Tag(zeek::IntrusivePtr<EnumVal> val)
analyzer::Tag::Tag(EnumValPtr val)
: ::Tag(std::move(val))
{ }

4
src/analyzer/Tag.h
View file

@ -89,7 +89,7 @@ public:
*
* @param etype the script-layer enum type associated with the tag.
*/
const zeek::IntrusivePtr<EnumVal>& AsVal() const;
const EnumValPtr& AsVal() const;
[[deprecated("Remove in v4.1. Use AsVal() instead.")]]
EnumVal* AsEnumVal() const;
@ -118,7 +118,7 @@ protected:
*
* @param val An enum value of script type \c Analyzer::Tag.
*/
explicit Tag(zeek::IntrusivePtr<EnumVal> val);
explicit Tag(EnumValPtr val);
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead")]]
explicit Tag(EnumVal* val);

4
src/analyzer/protocol/arp/ARP.cc
View file

@ -226,7 +226,7 @@ void ARP_Analyzer::RREvent(EventHandlerPtr e,
AddrVal* ARP_Analyzer::ConstructAddrVal(const void* addr)
{ return ToAddrVal(addr).release(); }
zeek::IntrusivePtr<AddrVal> ARP_Analyzer::ToAddrVal(const void* addr)
AddrValPtr ARP_Analyzer::ToAddrVal(const void* addr)
{
// ### For now, we only handle IPv4 addresses.
return zeek::make_intrusive<AddrVal>(*(const uint32_t*) addr);
@ -235,7 +235,7 @@ zeek::IntrusivePtr<AddrVal> ARP_Analyzer::ToAddrVal(const void* addr)
StringVal* ARP_Analyzer::EthAddrToStr(const u_char* addr)
{ return ToEthAddrStr(addr).release(); }
zeek::IntrusivePtr<StringVal> ARP_Analyzer::ToEthAddrStr(const u_char* addr)
StringValPtr ARP_Analyzer::ToEthAddrStr(const u_char* addr)
{
char buf[1024];
snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",

4
src/analyzer/protocol/arp/ARP.h
View file

@ -51,8 +51,8 @@ protected:
[[deprecated("Remove in v4.1. Use ToEthAddrStr().")]]
StringVal* EthAddrToStr(const u_char* addr);
zeek::IntrusivePtr<AddrVal> ToAddrVal(const void* addr);
zeek::IntrusivePtr<StringVal> ToEthAddrStr(const u_char* addr);
AddrValPtr ToAddrVal(const void* addr);
StringValPtr ToEthAddrStr(const u_char* addr);
void BadARP(const struct arp_pkthdr* hdr, const char* string);
void Corrupted(const char* string);
};

24
src/analyzer/protocol/asn1/asn1.pac
View file

@ -3,12 +3,12 @@
%}
%header{
zeek::IntrusivePtr<Val> asn1_integer_to_val(const ASN1Encoding* i, zeek::TypeTag t);
zeek::IntrusivePtr<Val> asn1_integer_to_val(const ASN1Integer* i, zeek::TypeTag t);
zeek::IntrusivePtr<StringVal> asn1_oid_to_val(const ASN1Encoding* oid);
zeek::IntrusivePtr<StringVal> asn1_oid_to_val(const ASN1ObjectIdentifier* oid);
zeek::IntrusivePtr<StringVal> asn1_octet_string_to_val(const ASN1Encoding* s);
zeek::IntrusivePtr<StringVal> asn1_octet_string_to_val(const ASN1OctetString* s);
ValPtr asn1_integer_to_val(const ASN1Encoding* i, zeek::TypeTag t);
ValPtr asn1_integer_to_val(const ASN1Integer* i, zeek::TypeTag t);
StringValPtr asn1_oid_to_val(const ASN1Encoding* oid);
StringValPtr asn1_oid_to_val(const ASN1ObjectIdentifier* oid);
StringValPtr asn1_octet_string_to_val(const ASN1Encoding* s);
StringValPtr asn1_octet_string_to_val(const ASN1OctetString* s);
%}
############################## ASN.1 Encodings
@ -102,12 +102,12 @@ function binary_to_int64(bs: bytestring): int64
%code{
zeek::IntrusivePtr<Val> asn1_integer_to_val(const ASN1Integer* i, zeek::TypeTag t)
ValPtr asn1_integer_to_val(const ASN1Integer* i, zeek::TypeTag t)
{
return asn1_integer_to_val(i->encoding(), t);
}
zeek::IntrusivePtr<Val> asn1_integer_to_val(const ASN1Encoding* i, zeek::TypeTag t)
ValPtr asn1_integer_to_val(const ASN1Encoding* i, zeek::TypeTag t)
{
auto v = binary_to_int64(i->content());
@ -125,12 +125,12 @@ zeek::IntrusivePtr<Val> asn1_integer_to_val(const ASN1Encoding* i, zeek::TypeTag
}
}
zeek::IntrusivePtr<StringVal> asn1_oid_to_val(const ASN1ObjectIdentifier* oid)
StringValPtr asn1_oid_to_val(const ASN1ObjectIdentifier* oid)
{
return asn1_oid_to_val(oid->encoding());
}
zeek::IntrusivePtr<StringVal> asn1_oid_to_val(const ASN1Encoding* oid)
StringValPtr asn1_oid_to_val(const ASN1Encoding* oid)
{
vector<uint64> oid_components;
vector<vector<uint8> > subidentifiers;
@ -194,12 +194,12 @@ zeek::IntrusivePtr<StringVal> asn1_oid_to_val(const ASN1Encoding* oid)
return zeek::make_intrusive<StringVal>(rval);
}
zeek::IntrusivePtr<StringVal> asn1_octet_string_to_val(const ASN1OctetString* s)
StringValPtr asn1_octet_string_to_val(const ASN1OctetString* s)
{
return asn1_octet_string_to_val(s->encoding());
}
zeek::IntrusivePtr<StringVal> asn1_octet_string_to_val(const ASN1Encoding* s)
StringValPtr asn1_octet_string_to_val(const ASN1Encoding* s)
{
bytestring const& bs = s->content();
return zeek::make_intrusive<StringVal>(bs.length(), reinterpret_cast<const char*>(bs.data()));

10
src/analyzer/protocol/bittorrent/BitTorrentTracker.cc
View file

@ -15,11 +15,11 @@
using namespace analyzer::bittorrent;
static zeek::IntrusivePtr<zeek::TableType> bt_tracker_headers;
static zeek::IntrusivePtr<zeek::RecordType> bittorrent_peer;
static zeek::IntrusivePtr<zeek::TableType> bittorrent_peer_set;
static zeek::IntrusivePtr<zeek::RecordType> bittorrent_benc_value;
static zeek::IntrusivePtr<zeek::TableType> bittorrent_benc_dir;
static zeek::TableTypePtr bt_tracker_headers;
static zeek::RecordTypePtr bittorrent_peer;
static zeek::TableTypePtr bittorrent_peer_set;
static zeek::RecordTypePtr bittorrent_benc_value;
static zeek::TableTypePtr bittorrent_benc_dir;
BitTorrentTracker_Analyzer::BitTorrentTracker_Analyzer(Connection* c)
: tcp::TCP_ApplicationAnalyzer("BITTORRENTTRACKER", c)

2
src/analyzer/protocol/dce-rpc/dce_rpc-analyzer.pac
View file

@ -83,7 +83,7 @@ refine connection DCE_RPC_Conn += {
%{
if ( dce_rpc_bind_ack )
{
zeek::IntrusivePtr<StringVal> sec_addr;
StringValPtr sec_addr;
// Remove the null from the end of the string if it's there.
if ( ${bind.sec_addr}.length() > 0 &&

4
src/analyzer/protocol/dhcp/dhcp-analyzer.pac
View file

@ -1,8 +1,8 @@
refine flow DHCP_Flow += {
%member{
zeek::IntrusivePtr<RecordVal> options;
zeek::IntrusivePtr<VectorVal> all_options;
RecordValPtr options;
VectorValPtr all_options;
%}
%init{

2
src/analyzer/protocol/dhcp/dhcp-options.pac
View file

@ -627,7 +627,7 @@ refine flow DHCP_Flow += {
%{
auto client_id = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::DHCP::ClientID);
client_id->Assign(0, val_mgr->Count(${v.client_id.hwtype}));
zeek::IntrusivePtr<StringVal> sv;
StringValPtr sv;
if ( ${v.client_id.hwtype} == 0 )
sv = zeek::make_intrusive<StringVal>(${v.client_id.hwaddr}.length(),

22
src/analyzer/protocol/dns/DNS.cc
View file

@ -1260,7 +1260,7 @@ bool DNS_Interpreter::ParseRR_HINFO(DNS_MsgInfo* msg,
return true;
}
static zeek::IntrusivePtr<StringVal>
static StringValPtr
extract_char_string(analyzer::Analyzer* analyzer,
const u_char*& data, int& len, int& rdlen)
{
@ -1300,7 +1300,7 @@ bool DNS_Interpreter::ParseRR_TXT(DNS_MsgInfo* msg,
}
auto char_strings = zeek::make_intrusive<VectorVal>(zeek::id::string_vec);
zeek::IntrusivePtr<StringVal> char_string;
StringValPtr char_string;
while ( (char_string = extract_char_string(analyzer, data, len, rdlength)) )
char_strings->Assign(char_strings->Size(), std::move(char_string));
@ -1328,7 +1328,7 @@ bool DNS_Interpreter::ParseRR_SPF(DNS_MsgInfo* msg,
}
auto char_strings = zeek::make_intrusive<VectorVal>(zeek::id::string_vec);
zeek::IntrusivePtr<StringVal> char_string;
StringValPtr char_string;
while ( (char_string = extract_char_string(analyzer, data, len, rdlength)) )
char_strings->Assign(char_strings->Size(), std::move(char_string));
@ -1446,7 +1446,7 @@ DNS_MsgInfo::DNS_MsgInfo(DNS_RawMsgHdr* hdr, int arg_is_query)
skip_event = 0;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildHdrVal()
RecordValPtr DNS_MsgInfo::BuildHdrVal()
{
static auto dns_msg = zeek::id::find_type<zeek::RecordType>("dns_msg");
auto r = zeek::make_intrusive<RecordVal>(dns_msg);
@ -1468,7 +1468,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildHdrVal()
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildAnswerVal()
RecordValPtr DNS_MsgInfo::BuildAnswerVal()
{
static auto dns_answer = zeek::id::find_type<zeek::RecordType>("dns_answer");
auto r = zeek::make_intrusive<RecordVal>(dns_answer);
@ -1482,7 +1482,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildAnswerVal()
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildEDNS_Val()
RecordValPtr DNS_MsgInfo::BuildEDNS_Val()
{
// We have to treat the additional record type in EDNS differently
// than a regular resource record.
@ -1518,7 +1518,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildEDNS_Val()
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildTSIG_Val(struct TSIG_DATA* tsig)
RecordValPtr DNS_MsgInfo::BuildTSIG_Val(struct TSIG_DATA* tsig)
{
static auto dns_tsig_additional = zeek::id::find_type<zeek::RecordType>("dns_tsig_additional");
auto r = zeek::make_intrusive<RecordVal>(dns_tsig_additional);
@ -1538,7 +1538,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildTSIG_Val(struct TSIG_DATA* tsig)
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildRRSIG_Val(RRSIG_DATA* rrsig)
RecordValPtr DNS_MsgInfo::BuildRRSIG_Val(RRSIG_DATA* rrsig)
{
static auto dns_rrsig_rr = zeek::id::find_type<zeek::RecordType>("dns_rrsig_rr");
auto r = zeek::make_intrusive<RecordVal>(dns_rrsig_rr);
@ -1559,7 +1559,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildRRSIG_Val(RRSIG_DATA* rrsig)
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildDNSKEY_Val(DNSKEY_DATA* dnskey)
RecordValPtr DNS_MsgInfo::BuildDNSKEY_Val(DNSKEY_DATA* dnskey)
{
static auto dns_dnskey_rr = zeek::id::find_type<zeek::RecordType>("dns_dnskey_rr");
auto r = zeek::make_intrusive<RecordVal>(dns_dnskey_rr);
@ -1575,7 +1575,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildDNSKEY_Val(DNSKEY_DATA* dnskey)
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildNSEC3_Val(NSEC3_DATA* nsec3)
RecordValPtr DNS_MsgInfo::BuildNSEC3_Val(NSEC3_DATA* nsec3)
{
static auto dns_nsec3_rr = zeek::id::find_type<zeek::RecordType>("dns_nsec3_rr");
auto r = zeek::make_intrusive<RecordVal>(dns_nsec3_rr);
@ -1595,7 +1595,7 @@ zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildNSEC3_Val(NSEC3_DATA* nsec3)
return r;
}
zeek::IntrusivePtr<RecordVal> DNS_MsgInfo::BuildDS_Val(DS_DATA* ds)
RecordValPtr DNS_MsgInfo::BuildDS_Val(DS_DATA* ds)
{
static auto dns_ds_rr = zeek::id::find_type<zeek::RecordType>("dns_ds_rr");
auto r = zeek::make_intrusive<RecordVal>(dns_ds_rr);

20
src/analyzer/protocol/dns/DNS.h
View file

@ -165,7 +165,7 @@ struct NSEC3_DATA {
BroString* nsec_salt;
unsigned short nsec_hlen;
BroString* nsec_hash;
zeek::IntrusivePtr<VectorVal> bitmaps;
VectorValPtr bitmaps;
};
struct DS_DATA {
@ -179,14 +179,14 @@ class DNS_MsgInfo {
public:
DNS_MsgInfo(DNS_RawMsgHdr* hdr, int is_query);
zeek::IntrusivePtr<RecordVal> BuildHdrVal();
zeek::IntrusivePtr<RecordVal> BuildAnswerVal();
zeek::IntrusivePtr<RecordVal> BuildEDNS_Val();
zeek::IntrusivePtr<RecordVal> BuildTSIG_Val(struct TSIG_DATA*);
zeek::IntrusivePtr<RecordVal> BuildRRSIG_Val(struct RRSIG_DATA*);
zeek::IntrusivePtr<RecordVal> BuildDNSKEY_Val(struct DNSKEY_DATA*);
zeek::IntrusivePtr<RecordVal> BuildNSEC3_Val(struct NSEC3_DATA*);
zeek::IntrusivePtr<RecordVal> BuildDS_Val(struct DS_DATA*);
RecordValPtr BuildHdrVal();
RecordValPtr BuildAnswerVal();
RecordValPtr BuildEDNS_Val();
RecordValPtr BuildTSIG_Val(struct TSIG_DATA*);
RecordValPtr BuildRRSIG_Val(struct RRSIG_DATA*);
RecordValPtr BuildDNSKEY_Val(struct DNSKEY_DATA*);
RecordValPtr BuildNSEC3_Val(struct NSEC3_DATA*);
RecordValPtr BuildDS_Val(struct DS_DATA*);
int id;
int opcode; ///< query type, see DNS_Opcode
@ -203,7 +203,7 @@ public:
int arcount; ///< number of additional RRs
int is_query; ///< whether it came from the session initiator
zeek::IntrusivePtr<StringVal> query_name;
StringValPtr query_name;
RR_Type atype;
int aclass; ///< normally = 1, inet
uint32_t ttl;

4
src/analyzer/protocol/ftp/functions.bif
View file

@ -4,7 +4,7 @@ type ftp_port: record;
%%{
#include "Reporter.h"
static zeek::IntrusivePtr<Val> parse_port(const char* line)
static ValPtr parse_port(const char* line)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::ftp_port);
@ -47,7 +47,7 @@ static zeek::IntrusivePtr<Val> parse_port(const char* line)
return r;
}
static zeek::IntrusivePtr<Val> parse_eftp(const char* line)
static ValPtr parse_eftp(const char* line)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::ftp_port);

52
src/analyzer/protocol/gtpv1/gtpv1-analyzer.pac
View file

@ -4,7 +4,7 @@
%}
%code{
zeek::IntrusivePtr<RecordVal> BuildGTPv1Hdr(const GTPv1_Header* pdu)
RecordValPtr BuildGTPv1Hdr(const GTPv1_Header* pdu)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtpv1_hdr);
@ -28,12 +28,12 @@ zeek::IntrusivePtr<RecordVal> BuildGTPv1Hdr(const GTPv1_Header* pdu)
return rv;
}
static zeek::IntrusivePtr<Val> BuildIMSI(const InformationElement* ie)
static ValPtr BuildIMSI(const InformationElement* ie)
{
return val_mgr->Count(ie->imsi()->value());
}
static zeek::IntrusivePtr<Val> BuildRAI(const InformationElement* ie)
static ValPtr BuildRAI(const InformationElement* ie)
{
auto ev = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtp_rai);
ev->Assign(0, val_mgr->Count(ie->rai()->mcc()));
@ -43,47 +43,47 @@ static zeek::IntrusivePtr<Val> BuildRAI(const InformationElement* ie)
return ev;
}
static zeek::IntrusivePtr<Val> BuildRecovery(const InformationElement* ie)
static ValPtr BuildRecovery(const InformationElement* ie)
{
return val_mgr->Count(ie->recovery()->restart_counter());
}
static zeek::IntrusivePtr<Val> BuildSelectionMode(const InformationElement* ie)
static ValPtr BuildSelectionMode(const InformationElement* ie)
{
return val_mgr->Count(ie->selection_mode()->mode());
}
static zeek::IntrusivePtr<Val> BuildTEID1(const InformationElement* ie)
static ValPtr BuildTEID1(const InformationElement* ie)
{
return val_mgr->Count(ie->teid1()->value());
}
static zeek::IntrusivePtr<Val> BuildTEID_ControlPlane(const InformationElement* ie)
static ValPtr BuildTEID_ControlPlane(const InformationElement* ie)
{
return val_mgr->Count(ie->teidcp()->value());
}
static zeek::IntrusivePtr<Val> BuildNSAPI(const InformationElement* ie)
static ValPtr BuildNSAPI(const InformationElement* ie)
{
return val_mgr->Count(ie->nsapi()->nsapi());
}
static zeek::IntrusivePtr<Val> BuildChargingCharacteristics(const InformationElement* ie)
static ValPtr BuildChargingCharacteristics(const InformationElement* ie)
{
return val_mgr->Count(ie->charging_characteristics()->value());
}
static zeek::IntrusivePtr<Val> BuildTraceReference(const InformationElement* ie)
static ValPtr BuildTraceReference(const InformationElement* ie)
{
return val_mgr->Count(ie->trace_reference()->value());
}
static zeek::IntrusivePtr<Val> BuildTraceType(const InformationElement* ie)
static ValPtr BuildTraceType(const InformationElement* ie)
{
return val_mgr->Count(ie->trace_type()->value());
}
zeek::IntrusivePtr<Val> BuildEndUserAddr(const InformationElement* ie)
ValPtr BuildEndUserAddr(const InformationElement* ie)
{
auto ev = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtp_end_user_addr);
ev->Assign(0, val_mgr->Count(ie->end_user_addr()->pdp_type_org()));
@ -114,21 +114,21 @@ zeek::IntrusivePtr<Val> BuildEndUserAddr(const InformationElement* ie)
return ev;
}
zeek::IntrusivePtr<Val> BuildAccessPointName(const InformationElement* ie)
ValPtr BuildAccessPointName(const InformationElement* ie)
{
BroString* bs = new BroString((const u_char*) ie->ap_name()->value().data(),
ie->ap_name()->value().length(), false);
return zeek::make_intrusive<StringVal>(bs);
}
zeek::IntrusivePtr<Val> BuildProtoConfigOptions(const InformationElement* ie)
ValPtr BuildProtoConfigOptions(const InformationElement* ie)
{
const u_char* d = (const u_char*) ie->proto_config_opts()->value().data();
int len = ie->proto_config_opts()->value().length();
return zeek::make_intrusive<StringVal>(new BroString(d, len, false));
}
zeek::IntrusivePtr<Val> BuildGSN_Addr(const InformationElement* ie)
ValPtr BuildGSN_Addr(const InformationElement* ie)
{
auto ev = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtp_gsn_addr);
@ -147,14 +147,14 @@ zeek::IntrusivePtr<Val> BuildGSN_Addr(const InformationElement* ie)
return ev;
}
zeek::IntrusivePtr<Val> BuildMSISDN(const InformationElement* ie)
ValPtr BuildMSISDN(const InformationElement* ie)
{
const u_char* d = (const u_char*) ie->msisdn()->value().data();
int len = ie->msisdn()->value().length();
return zeek::make_intrusive<StringVal>(new BroString(d, len, false));
}
zeek::IntrusivePtr<Val> BuildQoS_Profile(const InformationElement* ie)
ValPtr BuildQoS_Profile(const InformationElement* ie)
{
auto ev = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtp_qos_profile);
@ -167,28 +167,28 @@ zeek::IntrusivePtr<Val> BuildQoS_Profile(const InformationElement* ie)
return ev;
}
zeek::IntrusivePtr<Val> BuildTrafficFlowTemplate(const InformationElement* ie)
ValPtr BuildTrafficFlowTemplate(const InformationElement* ie)
{
const uint8* d = ie->traffic_flow_template()->value().data();
int len = ie->traffic_flow_template()->value().length();
return zeek::make_intrusive<StringVal>(new BroString((const u_char*) d, len, false));
}
zeek::IntrusivePtr<Val> BuildTriggerID(const InformationElement* ie)
ValPtr BuildTriggerID(const InformationElement* ie)
{
const uint8* d = ie->trigger_id()->value().data();
int len = ie->trigger_id()->value().length();
return zeek::make_intrusive<StringVal>(new BroString((const u_char*) d, len, false));
}
zeek::IntrusivePtr<Val> BuildOMC_ID(const InformationElement* ie)
ValPtr BuildOMC_ID(const InformationElement* ie)
{
const uint8* d = ie->omc_id()->value().data();
int len = ie->omc_id()->value().length();
return zeek::make_intrusive<StringVal>(new BroString((const u_char*) d, len, false));
}
zeek::IntrusivePtr<Val> BuildPrivateExt(const InformationElement* ie)
ValPtr BuildPrivateExt(const InformationElement* ie)
{
auto ev = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::gtp_private_extension);
@ -201,22 +201,22 @@ zeek::IntrusivePtr<Val> BuildPrivateExt(const InformationElement* ie)
return ev;
}
static zeek::IntrusivePtr<Val> BuildCause(const InformationElement* ie)
static ValPtr BuildCause(const InformationElement* ie)
{
return val_mgr->Count(ie->cause()->value());
}
static zeek::IntrusivePtr<Val> BuildReorderReq(const InformationElement* ie)
static ValPtr BuildReorderReq(const InformationElement* ie)
{
return val_mgr->Bool(ie->reorder_req()->req());
}
static zeek::IntrusivePtr<Val> BuildChargingID(const InformationElement* ie)
static ValPtr BuildChargingID(const InformationElement* ie)
{
return val_mgr->Count(ie->charging_id()->value());;
}
zeek::IntrusivePtr<Val> BuildChargingGatewayAddr(const InformationElement* ie)
ValPtr BuildChargingGatewayAddr(const InformationElement* ie)
{
const uint8* d = ie->charging_gateway_addr()->value().data();
int len = ie->charging_gateway_addr()->value().length();
@ -228,7 +228,7 @@ zeek::IntrusivePtr<Val> BuildChargingGatewayAddr(const InformationElement* ie)
return nullptr;
}
static zeek::IntrusivePtr<Val> BuildTeardownInd(const InformationElement* ie)
static ValPtr BuildTeardownInd(const InformationElement* ie)
{
return val_mgr->Bool(ie->teardown_ind()->ind());
}

8
src/analyzer/protocol/http/HTTP.cc
View file

@ -613,7 +613,7 @@ HTTP_Message::~HTTP_Message()
delete [] entity_data_buffer;
}
zeek::IntrusivePtr<RecordVal> HTTP_Message::BuildMessageStat(bool interrupted, const char* msg)
RecordValPtr HTTP_Message::BuildMessageStat(bool interrupted, const char* msg)
{
static auto http_message_stat = zeek::id::find_type<zeek::RecordType>("http_message_stat");
auto stat = zeek::make_intrusive<RecordVal>(http_message_stat);
@ -1355,7 +1355,7 @@ void HTTP_Analyzer::HTTP_Event(const char* category, const char* detail)
HTTP_Event(category, zeek::make_intrusive<StringVal>(detail));
}
void HTTP_Analyzer::HTTP_Event(const char* category, zeek::IntrusivePtr<StringVal> detail)
void HTTP_Analyzer::HTTP_Event(const char* category, StringValPtr detail)
{
if ( http_event )
// DEBUG_MSG("%.6f http_event\n", network_time);
@ -1365,8 +1365,8 @@ void HTTP_Analyzer::HTTP_Event(const char* category, zeek::IntrusivePtr<StringVa
std::move(detail));
}
zeek::IntrusivePtr<StringVal>
HTTP_Analyzer::TruncateURI(const zeek::IntrusivePtr<StringVal>& uri)
StringValPtr
HTTP_Analyzer::TruncateURI(const StringValPtr& uri)
{
const BroString* str = uri->AsString();

16
src/analyzer/protocol/http/HTTP.h
View file

@ -145,7 +145,7 @@ protected:
HTTP_Entity* current_entity;
zeek::IntrusivePtr<RecordVal> BuildMessageStat(bool interrupted, const char* msg);
RecordValPtr BuildMessageStat(bool interrupted, const char* msg);
};
class HTTP_Analyzer final : public tcp::TCP_ApplicationAnalyzer {
@ -156,7 +156,7 @@ public:
void HTTP_EntityData(bool is_orig, BroString* entity_data);
void HTTP_MessageDone(bool is_orig, HTTP_Message* message);
void HTTP_Event(const char* category, const char* detail);
void HTTP_Event(const char* category, zeek::IntrusivePtr<StringVal> detail);
void HTTP_Event(const char* category, StringValPtr detail);
void SkipEntityData(bool is_orig);
@ -237,7 +237,7 @@ protected:
int HTTP_ReplyCode(const char* code_str);
int ExpectReplyMessageBody();
zeek::IntrusivePtr<StringVal> TruncateURI(const zeek::IntrusivePtr<StringVal>& uri);
StringValPtr TruncateURI(const StringValPtr& uri);
int request_state, reply_state;
int num_requests, num_replies;
@ -257,19 +257,19 @@ protected:
// in a reply.
std::string upgrade_protocol;
zeek::IntrusivePtr<StringVal> request_method;
StringValPtr request_method;
// request_URI is in the original form (may contain '%<hex><hex>'
// sequences).
zeek::IntrusivePtr<StringVal> request_URI;
StringValPtr request_URI;
// unescaped_URI does not contain escaped sequences.
zeek::IntrusivePtr<StringVal> unescaped_URI;
StringValPtr unescaped_URI;
std::queue<zeek::IntrusivePtr<StringVal>> unanswered_requests;
std::queue<StringValPtr> unanswered_requests;
int reply_code;
zeek::IntrusivePtr<StringVal> reply_reason_phrase;
StringValPtr reply_reason_phrase;
tcp::ContentLine_Analyzer* content_line_orig;
tcp::ContentLine_Analyzer* content_line_resp;

10
src/analyzer/protocol/icmp/ICMP.cc
View file

@ -219,7 +219,7 @@ void ICMP_Analyzer::ICMP_Sent(const struct icmp* icmpp, int len, int caplen,
}
}
zeek::IntrusivePtr<RecordVal>
RecordValPtr
ICMP_Analyzer::BuildICMPVal(const struct icmp* icmpp, int len,
int icmpv6, const IP_Hdr* ip_hdr)
{
@ -305,7 +305,7 @@ TransportProto ICMP_Analyzer::GetContextProtocol(const IP_Hdr* ip_hdr, uint32_t*
return proto;
}
zeek::IntrusivePtr<RecordVal> ICMP_Analyzer::ExtractICMP4Context(int len, const u_char*& data)
RecordValPtr ICMP_Analyzer::ExtractICMP4Context(int len, const u_char*& data)
{
const IP_Hdr ip_hdr_data((const struct ip*) data, false);
const IP_Hdr* ip_hdr = &ip_hdr_data;
@ -372,7 +372,7 @@ zeek::IntrusivePtr<RecordVal> ICMP_Analyzer::ExtractICMP4Context(int len, const
return iprec;
}
zeek::IntrusivePtr<RecordVal> ICMP_Analyzer::ExtractICMP6Context(int len, const u_char*& data)
RecordValPtr ICMP_Analyzer::ExtractICMP6Context(int len, const u_char*& data)
{
int DF = 0, MF = 0, bad_hdr_len = 0;
TransportProto proto = TRANSPORT_UNKNOWN;
@ -469,7 +469,7 @@ void ICMP_Analyzer::UpdateConnVal(RecordVal *conn_val)
Analyzer::UpdateConnVal(conn_val);
}
void ICMP_Analyzer::UpdateEndpointVal(const zeek::IntrusivePtr<Val>& endp_arg, bool is_orig)
void ICMP_Analyzer::UpdateEndpointVal(const ValPtr& endp_arg, bool is_orig)
{
Conn()->EnableStatusUpdateTimer();
@ -722,7 +722,7 @@ void ICMP_Analyzer::Context6(double t, const struct icmp* icmpp,
);
}
zeek::IntrusivePtr<VectorVal> ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
VectorValPtr ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
{
static auto icmp6_nd_option_type = zeek::id::find_type<zeek::RecordType>("icmp6_nd_option");
static auto icmp6_nd_prefix_info_type = zeek::id::find_type<zeek::RecordType>("icmp6_nd_prefix_info");

13
src/analyzer/protocol/icmp/ICMP.h
View file

@ -7,6 +7,7 @@
#include "net_util.h"
class VectorVal;
using VectorValPtr = zeek::IntrusivePtr<VectorVal>;
namespace analyzer { namespace icmp {
@ -51,13 +52,13 @@ protected:
void Describe(ODesc* d) const;
zeek::IntrusivePtr<RecordVal> BuildICMPVal(const struct icmp* icmpp, int len,
RecordValPtr BuildICMPVal(const struct icmp* icmpp, int len,
int icmpv6, const IP_Hdr* ip_hdr);
void NextICMP4(double t, const struct icmp* icmpp, int len, int caplen,
const u_char*& data, const IP_Hdr* ip_hdr );
zeek::IntrusivePtr<RecordVal> ExtractICMP4Context(int len, const u_char*& data);
RecordValPtr ExtractICMP4Context(int len, const u_char*& data);
void Context4(double t, const struct icmp* icmpp, int len, int caplen,
const u_char*& data, const IP_Hdr* ip_hdr);
@ -68,15 +69,15 @@ protected:
void NextICMP6(double t, const struct icmp* icmpp, int len, int caplen,
const u_char*& data, const IP_Hdr* ip_hdr );
zeek::IntrusivePtr<RecordVal> ExtractICMP6Context(int len, const u_char*& data);
RecordValPtr ExtractICMP6Context(int len, const u_char*& data);
void Context6(double t, const struct icmp* icmpp, int len, int caplen,
const u_char*& data, const IP_Hdr* ip_hdr);
// RFC 4861 Neighbor Discover message options
zeek::IntrusivePtr<VectorVal> BuildNDOptionsVal(int caplen, const u_char* data);
VectorValPtr BuildNDOptionsVal(int caplen, const u_char* data);
zeek::IntrusivePtr<RecordVal> icmp_conn_val;
RecordValPtr icmp_conn_val;
int type;
int code;
int request_len, reply_len;
@ -84,7 +85,7 @@ protected:
RuleMatcherState matcher_state;
private:
void UpdateEndpointVal(const zeek::IntrusivePtr<Val>& endp, bool is_orig);
void UpdateEndpointVal(const ValPtr& endp, bool is_orig);
};
// Returns the counterpart type to the given type (e.g., the counterpart

6
src/analyzer/protocol/krb/KRB.cc
View file

@ -87,9 +87,9 @@ void KRB_Analyzer::DeliverPacket(int len, const u_char* data, bool orig,
}
}
zeek::IntrusivePtr<StringVal> KRB_Analyzer::GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype)
StringValPtr KRB_Analyzer::GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype)
{
#ifdef USE_KRB5
if ( !krb_available )

6
src/analyzer/protocol/krb/KRB.h
View file

@ -25,9 +25,9 @@ public:
static analyzer::Analyzer* Instantiate(Connection* conn)
{ return new KRB_Analyzer(conn); }
zeek::IntrusivePtr<StringVal> GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype);
StringValPtr GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype);
protected:

6
src/analyzer/protocol/krb/KRB_TCP.h
View file

@ -21,9 +21,9 @@ public:
// Overriden from tcp::TCP_ApplicationAnalyzer.
void EndpointEOF(bool is_orig) override;
zeek::IntrusivePtr<StringVal> GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype)
StringValPtr GetAuthenticationInfo(const BroString* principal,
const BroString* ciphertext,
const bro_uint_t enctype)
{ return val_mgr->EmptyString(); }
static analyzer::Analyzer* Instantiate(Connection* conn)

10
src/analyzer/protocol/krb/krb-analyzer.pac
View file

@ -1,12 +1,12 @@
%header{
zeek::IntrusivePtr<RecordVal> proc_krb_kdc_options(const KRB_KDC_Options* opts);
zeek::IntrusivePtr<RecordVal> proc_krb_kdc_req_arguments(KRB_KDC_REQ* msg, const BroAnalyzer bro_analyzer);
RecordValPtr proc_krb_kdc_options(const KRB_KDC_Options* opts);
RecordValPtr proc_krb_kdc_req_arguments(KRB_KDC_REQ* msg, const BroAnalyzer bro_analyzer);
bool proc_error_arguments(RecordVal* rv, const std::vector<KRB_ERROR_Arg*>* args, int64 error_code);
%}
%code{
zeek::IntrusivePtr<RecordVal> proc_krb_kdc_options(const KRB_KDC_Options* opts)
RecordValPtr proc_krb_kdc_options(const KRB_KDC_Options* opts)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::KRB::KDC_Options);
@ -27,7 +27,7 @@ zeek::IntrusivePtr<RecordVal> proc_krb_kdc_options(const KRB_KDC_Options* opts)
return rv;
}
zeek::IntrusivePtr<RecordVal> proc_krb_kdc_req_arguments(KRB_KDC_REQ* msg, const BroAnalyzer bro_analyzer)
RecordValPtr proc_krb_kdc_req_arguments(KRB_KDC_REQ* msg, const BroAnalyzer bro_analyzer)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::KRB::KDC_Request);
@ -201,7 +201,7 @@ refine connection KRB_Conn += {
%{
bro_analyzer()->ProtocolConfirmation();
auto msg_type = binary_to_int64(${msg.msg_type.data.content});
auto make_arg = [this, msg]() -> zeek::IntrusivePtr<RecordVal>
auto make_arg = [this, msg]() -> RecordValPtr
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::KRB::KDC_Response);

8
src/analyzer/protocol/krb/krb-asn1.pac
View file

@ -2,20 +2,20 @@
%include ../asn1/asn1.pac
%header{
zeek::IntrusivePtr<Val> GetTimeFromAsn1(const KRB_Time* atime, int64 usecs);
zeek::IntrusivePtr<Val> GetTimeFromAsn1(StringVal* atime, int64 usecs);
ValPtr GetTimeFromAsn1(const KRB_Time* atime, int64 usecs);
ValPtr GetTimeFromAsn1(StringVal* atime, int64 usecs);
%}
%code{
zeek::IntrusivePtr<Val> GetTimeFromAsn1(const KRB_Time* atime, int64 usecs)
ValPtr GetTimeFromAsn1(const KRB_Time* atime, int64 usecs)
{
auto atime_bytestring = to_stringval(atime->time());
auto result = GetTimeFromAsn1(atime_bytestring.get(), usecs);
return result;
}
zeek::IntrusivePtr<Val> GetTimeFromAsn1(StringVal* atime, int64 usecs)
ValPtr GetTimeFromAsn1(StringVal* atime, int64 usecs)
{
time_t lResult = 0;

4
src/analyzer/protocol/krb/krb-padata.pac
View file

@ -7,11 +7,11 @@
%}
%header{
zeek::IntrusivePtr<VectorVal> proc_padata(const KRB_PA_Data_Sequence* data, const BroAnalyzer bro_analyzer, bool is_error);
VectorValPtr proc_padata(const KRB_PA_Data_Sequence* data, const BroAnalyzer bro_analyzer, bool is_error);
%}
%code{
zeek::IntrusivePtr<VectorVal> proc_padata(const KRB_PA_Data_Sequence* data, const BroAnalyzer bro_analyzer, bool is_error)
VectorValPtr proc_padata(const KRB_PA_Data_Sequence* data, const BroAnalyzer bro_analyzer, bool is_error)
{
auto vv = zeek::make_intrusive<VectorVal>(zeek::id::find_type<zeek::VectorType>("KRB::Type_Value_Vector"));

24
src/analyzer/protocol/krb/krb-types.pac
View file

@ -1,19 +1,19 @@
# Fundamental KRB types
%header{
zeek::IntrusivePtr<Val> GetStringFromPrincipalName(const KRB_Principal_Name* pname);
ValPtr GetStringFromPrincipalName(const KRB_Principal_Name* pname);
zeek::IntrusivePtr<VectorVal> proc_cipher_list(const Array* list);
VectorValPtr proc_cipher_list(const Array* list);
zeek::IntrusivePtr<VectorVal> proc_host_address_list(const BroAnalyzer a, const KRB_Host_Addresses* list);
zeek::IntrusivePtr<RecordVal> proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr);
VectorValPtr proc_host_address_list(const BroAnalyzer a, const KRB_Host_Addresses* list);
RecordValPtr proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr);
zeek::IntrusivePtr<VectorVal> proc_tickets(const KRB_Ticket_Sequence* list);
zeek::IntrusivePtr<RecordVal> proc_ticket(const KRB_Ticket* ticket);
VectorValPtr proc_tickets(const KRB_Ticket_Sequence* list);
RecordValPtr proc_ticket(const KRB_Ticket* ticket);
%}
%code{
zeek::IntrusivePtr<Val> GetStringFromPrincipalName(const KRB_Principal_Name* pname)
ValPtr GetStringFromPrincipalName(const KRB_Principal_Name* pname)
{
if ( pname->data()->size() == 1 )
return to_stringval(pname->data()[0][0]->encoding()->content());
@ -25,7 +25,7 @@ zeek::IntrusivePtr<Val> GetStringFromPrincipalName(const KRB_Principal_Name* pna
return zeek::make_intrusive<StringVal>("unknown");
}
zeek::IntrusivePtr<VectorVal> proc_cipher_list(const Array* list)
VectorValPtr proc_cipher_list(const Array* list)
{
auto ciphers = zeek::make_intrusive<VectorVal>(zeek::id::index_vec);
for ( uint i = 0; i < list->data()->size(); ++i )
@ -33,7 +33,7 @@ zeek::IntrusivePtr<VectorVal> proc_cipher_list(const Array* list)
return ciphers;
}
zeek::IntrusivePtr<VectorVal> proc_host_address_list(const BroAnalyzer a, const KRB_Host_Addresses* list)
VectorValPtr proc_host_address_list(const BroAnalyzer a, const KRB_Host_Addresses* list)
{
auto addrs = zeek::make_intrusive<VectorVal>(zeek::id::find_type<zeek::VectorType>("KRB::Host_Address_Vector"));
@ -45,7 +45,7 @@ zeek::IntrusivePtr<VectorVal> proc_host_address_list(const BroAnalyzer a, const
return addrs;
}
zeek::IntrusivePtr<RecordVal> proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr)
RecordValPtr proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::KRB::Host_Address);
const auto& addr_bytes = addr->address()->data()->content();
@ -92,7 +92,7 @@ zeek::IntrusivePtr<RecordVal> proc_host_address(const BroAnalyzer a, const KRB_H
return rv;
}
zeek::IntrusivePtr<VectorVal> proc_tickets(const KRB_Ticket_Sequence* list)
VectorValPtr proc_tickets(const KRB_Ticket_Sequence* list)
{
auto tickets = zeek::make_intrusive<VectorVal>(zeek::id::find_type<zeek::VectorType>("KRB::Ticket_Vector"));
@ -105,7 +105,7 @@ zeek::IntrusivePtr<VectorVal> proc_tickets(const KRB_Ticket_Sequence* list)
return tickets;
}
zeek::IntrusivePtr<RecordVal> proc_ticket(const KRB_Ticket* ticket)
RecordValPtr proc_ticket(const KRB_Ticket* ticket)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::KRB::Ticket);

14
src/analyzer/protocol/login/Login.cc
View file

@ -45,13 +45,13 @@ Login_Analyzer::Login_Analyzer(const char* name, Connection* conn)
if ( ! re_skip_authentication )
{
zeek::IntrusivePtr<ListVal> skip_authentication = zeek::id::find_val("skip_authentication")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> direct_login_prompts = zeek::id::find_val("direct_login_prompts")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> login_prompts = zeek::id::find_val("login_prompts")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> login_non_failure_msgs = zeek::id::find_val("login_non_failure_msgs")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> login_failure_msgs = zeek::id::find_val("login_failure_msgs")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> login_success_msgs = zeek::id::find_val("login_success_msgs")->AsTableVal()->ToPureListVal();
zeek::IntrusivePtr<ListVal> login_timeouts = zeek::id::find_val("login_timeouts")->AsTableVal()->ToPureListVal();
ListValPtr skip_authentication = zeek::id::find_val("skip_authentication")->AsTableVal()->ToPureListVal();
ListValPtr direct_login_prompts = zeek::id::find_val("direct_login_prompts")->AsTableVal()->ToPureListVal();
ListValPtr login_prompts = zeek::id::find_val("login_prompts")->AsTableVal()->ToPureListVal();
ListValPtr login_non_failure_msgs = zeek::id::find_val("login_non_failure_msgs")->AsTableVal()->ToPureListVal();
ListValPtr login_failure_msgs = zeek::id::find_val("login_failure_msgs")->AsTableVal()->ToPureListVal();
ListValPtr login_success_msgs = zeek::id::find_val("login_success_msgs")->AsTableVal()->ToPureListVal();
ListValPtr login_timeouts = zeek::id::find_val("login_timeouts")->AsTableVal()->ToPureListVal();
#ifdef USE_PERFTOOLS_DEBUG
HeapLeakChecker::Disabler disabler;

10
src/analyzer/protocol/mime/MIME.cc
View file

@ -117,17 +117,17 @@ StringVal* new_string_val(const char* data, const char* end_of_data)
StringVal* new_string_val(const data_chunk_t buf)
{ return to_string_val(buf).release(); }
zeek::IntrusivePtr<StringVal> to_string_val(int length, const char* data)
StringValPtr to_string_val(int length, const char* data)
{
return zeek::make_intrusive<StringVal>(length, data);
}
zeek::IntrusivePtr<StringVal> to_string_val(const char* data, const char* end_of_data)
StringValPtr to_string_val(const char* data, const char* end_of_data)
{
return zeek::make_intrusive<StringVal>(end_of_data - data, data);
}
zeek::IntrusivePtr<StringVal> to_string_val(const data_chunk_t buf)
StringValPtr to_string_val(const data_chunk_t buf)
{
return to_string_val(buf.length, buf.data);
}
@ -1301,7 +1301,7 @@ void MIME_Entity::DebugPrintHeaders()
RecordVal* MIME_Message::BuildHeaderVal(MIME_Header* h)
{ return ToHeaderVal(h).release(); }
zeek::IntrusivePtr<RecordVal> MIME_Message::ToHeaderVal(MIME_Header* h)
RecordValPtr MIME_Message::ToHeaderVal(MIME_Header* h)
{
static auto mime_header_rec = zeek::id::find_type<zeek::RecordType>("mime_header_rec");
auto header_record = zeek::make_intrusive<RecordVal>(mime_header_rec);
@ -1316,7 +1316,7 @@ zeek::IntrusivePtr<RecordVal> MIME_Message::ToHeaderVal(MIME_Header* h)
TableVal* MIME_Message::BuildHeaderTable(MIME_HeaderList& hlist)
{ return ToHeaderTable(hlist).release(); }
zeek::IntrusivePtr<TableVal> MIME_Message::ToHeaderTable(MIME_HeaderList& hlist)
TableValPtr MIME_Message::ToHeaderTable(MIME_HeaderList& hlist)
{
static auto mime_header_list = zeek::id::find_type<zeek::TableType>("mime_header_list");
auto t = zeek::make_intrusive<TableVal>(mime_header_list);

21
src/analyzer/protocol/mime/MIME.h
View file

@ -14,6 +14,9 @@ class TableVal;
class StringVal;
class Base64Converter;
using TableValPtr = zeek::IntrusivePtr<TableVal>;
using StringValPtr = zeek::IntrusivePtr<StringVal>;
namespace analyzer { namespace mime {
// MIME: Multipurpose Internet Mail Extensions
@ -102,8 +105,8 @@ public:
StringVal* ContentType() const { return content_type_str.get(); }
[[deprecated("Remove in v4.1. Use GetContentSubType().")]]
StringVal* ContentSubType() const { return content_subtype_str.get(); }
const zeek::IntrusivePtr<StringVal>& GetContentType() const { return content_type_str; }
const zeek::IntrusivePtr<StringVal>& GetContentSubType() const { return content_subtype_str; }
const StringValPtr& GetContentType() const { return content_type_str; }
const StringValPtr& GetContentSubType() const { return content_subtype_str; }
int ContentTransferEncoding() const { return content_encoding; }
protected:
@ -159,8 +162,8 @@ protected:
int current_field_type;
int need_to_parse_parameters;
zeek::IntrusivePtr<StringVal> content_type_str;
zeek::IntrusivePtr<StringVal> content_subtype_str;
StringValPtr content_type_str;
StringValPtr content_subtype_str;
BroString* content_encoding_str;
BroString* multipart_boundary;
@ -235,8 +238,8 @@ protected:
[[deprecated("Remove in v4.1. Use ToHeaderTable().")]]
TableVal* BuildHeaderTable(MIME_HeaderList& hlist);
zeek::IntrusivePtr<RecordVal> ToHeaderVal(MIME_Header* h);
zeek::IntrusivePtr<TableVal> ToHeaderTable(MIME_HeaderList& hlist);
RecordValPtr ToHeaderVal(MIME_Header* h);
TableValPtr ToHeaderTable(MIME_HeaderList& hlist);
};
class MIME_Mail final : public MIME_Message {
@ -281,9 +284,9 @@ extern StringVal* new_string_val(int length, const char* data);
extern StringVal* new_string_val(const char* data, const char* end_of_data);
[[deprecated("Remove in v4.1. Use analyzer::mime::to_string_val().")]]
extern StringVal* new_string_val(const data_chunk_t buf);
extern zeek::IntrusivePtr<StringVal> to_string_val(int length, const char* data);
extern zeek::IntrusivePtr<StringVal> to_string_val(const char* data, const char* end_of_data);
extern zeek::IntrusivePtr<StringVal> to_string_val(const data_chunk_t buf);
extern StringValPtr to_string_val(int length, const char* data);
extern StringValPtr to_string_val(const char* data, const char* end_of_data);
extern StringValPtr to_string_val(const data_chunk_t buf);
extern int fputs(data_chunk_t b, FILE* fp);
extern bool istrequal(data_chunk_t s, const char* t);
extern bool is_lws(char ch);

12
src/analyzer/protocol/modbus/modbus-analyzer.pac
View file

@ -8,13 +8,13 @@
#
%header{
zeek::IntrusivePtr<VectorVal> bytestring_to_coils(const bytestring& coils, uint quantity);
zeek::IntrusivePtr<RecordVal> HeaderToVal(ModbusTCP_TransportHeader* header);
zeek::IntrusivePtr<VectorVal> create_vector_of_count();
VectorValPtr bytestring_to_coils(const bytestring& coils, uint quantity);
RecordValPtr HeaderToVal(ModbusTCP_TransportHeader* header);
VectorValPtr create_vector_of_count();
%}
%code{
zeek::IntrusivePtr<VectorVal> bytestring_to_coils(const bytestring& coils, uint quantity)
VectorValPtr bytestring_to_coils(const bytestring& coils, uint quantity)
{
auto modbus_coils = zeek::make_intrusive<VectorVal>(zeek::BifType::Vector::ModbusCoils);
@ -27,7 +27,7 @@
return modbus_coils;
}
zeek::IntrusivePtr<RecordVal> HeaderToVal(ModbusTCP_TransportHeader* header)
RecordValPtr HeaderToVal(ModbusTCP_TransportHeader* header)
{
auto modbus_header = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::ModbusHeaders);
modbus_header->Assign(0, val_mgr->Count(header->tid()));
@ -37,7 +37,7 @@
return modbus_header;
}
zeek::IntrusivePtr<VectorVal> create_vector_of_count()
VectorValPtr create_vector_of_count()
{
auto vt = zeek::make_intrusive<zeek::VectorType>(zeek::base_type(zeek::TYPE_COUNT));
auto vv = zeek::make_intrusive<VectorVal>(std::move(vt));

12
src/analyzer/protocol/ntlm/ntlm-analyzer.pac
View file

@ -1,12 +1,12 @@
%header{
zeek::IntrusivePtr<Val> filetime2brotime(uint64_t ts);
zeek::IntrusivePtr<RecordVal> build_version_record(NTLM_Version* val);
zeek::IntrusivePtr<RecordVal> build_negotiate_flag_record(NTLM_Negotiate_Flags* val);
ValPtr filetime2brotime(uint64_t ts);
RecordValPtr build_version_record(NTLM_Version* val);
RecordValPtr build_negotiate_flag_record(NTLM_Negotiate_Flags* val);
%}
%code{
// This is replicated from the SMB analyzer. :(
zeek::IntrusivePtr<Val> filetime2brotime(uint64_t ts)
ValPtr filetime2brotime(uint64_t ts)
{
double secs = (ts / 10000000.0);
@ -17,7 +17,7 @@
return bro_ts;
}
zeek::IntrusivePtr<RecordVal> build_version_record(NTLM_Version* val)
RecordValPtr build_version_record(NTLM_Version* val)
{
auto result = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NTLM::Version);
result->Assign(0, val_mgr->Count(${val.major_version}));
@ -28,7 +28,7 @@
return result;
}
zeek::IntrusivePtr<RecordVal> build_negotiate_flag_record(NTLM_Negotiate_Flags* val)
RecordValPtr build_negotiate_flag_record(NTLM_Negotiate_Flags* val)
{
auto flags = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NTLM::NegotiateFlags);
flags->Assign(0, val_mgr->Bool(${val.negotiate_56}));

20
src/analyzer/protocol/ntp/ntp-analyzer.pac
View file

@ -8,23 +8,23 @@
%}
%header{
zeek::IntrusivePtr<Val> proc_ntp_short(const NTP_Short_Time* t);
zeek::IntrusivePtr<Val> proc_ntp_timestamp(const NTP_Time* t);
zeek::IntrusivePtr<RecordVal> BuildNTPStdMsg(NTP_std_msg* nsm);
zeek::IntrusivePtr<RecordVal> BuildNTPControlMsg(NTP_control_msg* ncm);
zeek::IntrusivePtr<RecordVal> BuildNTPMode7Msg(NTP_mode7_msg* m7);
ValPtr proc_ntp_short(const NTP_Short_Time* t);
ValPtr proc_ntp_timestamp(const NTP_Time* t);
RecordValPtr BuildNTPStdMsg(NTP_std_msg* nsm);
RecordValPtr BuildNTPControlMsg(NTP_control_msg* ncm);
RecordValPtr BuildNTPMode7Msg(NTP_mode7_msg* m7);
%}
%code{
zeek::IntrusivePtr<Val> proc_ntp_short(const NTP_Short_Time* t)
ValPtr proc_ntp_short(const NTP_Short_Time* t)
{
if ( t->seconds() == 0 && t->fractions() == 0 )
return zeek::make_intrusive<IntervalVal>(0.0);
return zeek::make_intrusive<IntervalVal>(t->seconds() + t->fractions()*FRAC_16);
}
zeek::IntrusivePtr<Val> proc_ntp_timestamp(const NTP_Time* t)
ValPtr proc_ntp_timestamp(const NTP_Time* t)
{
if ( t->seconds() == 0 && t->fractions() == 0)
return zeek::make_intrusive<TimeVal>(0.0);
@ -32,7 +32,7 @@
}
// This builds the standard msg record
zeek::IntrusivePtr<RecordVal> BuildNTPStdMsg(NTP_std_msg* nsm)
RecordValPtr BuildNTPStdMsg(NTP_std_msg* nsm)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NTP::StandardMessage);
@ -85,7 +85,7 @@
}
// This builds the control msg record
zeek::IntrusivePtr<RecordVal> BuildNTPControlMsg(NTP_control_msg* ncm)
RecordValPtr BuildNTPControlMsg(NTP_control_msg* ncm)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NTP::ControlMessage);
@ -110,7 +110,7 @@
}
// This builds the mode7 msg record
zeek::IntrusivePtr<RecordVal> BuildNTPMode7Msg(NTP_mode7_msg* m7)
RecordValPtr BuildNTPMode7Msg(NTP_mode7_msg* m7)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NTP::Mode7Message);

2
src/analyzer/protocol/radius/radius-analyzer.pac
View file

@ -22,7 +22,7 @@ refine flow RADIUS_Flow += {
// Do we already have a vector of attributes for this type?
auto current = attributes->FindOrDefault(index);
zeek::IntrusivePtr<Val> val = to_stringval(${msg.attributes[i].value});
ValPtr val = to_stringval(${msg.attributes[i].value});
if ( current )
{

16
src/analyzer/protocol/rpc/MOUNT.cc
View file

@ -22,7 +22,7 @@ bool MOUNT_Interp::RPC_BuildCall(RPC_CallInfo* c, const u_char*& buf, int& n)
uint32_t proc = c->Proc();
// The call arguments, depends on the call type obviously ...
zeek::IntrusivePtr<RecordVal> callarg;
RecordValPtr callarg;
switch ( proc ) {
case BifEnum::MOUNT3::PROC_NULL:
@ -69,7 +69,7 @@ bool MOUNT_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_statu
double last_time, int reply_len)
{
EventHandlerPtr event = nullptr;
zeek::IntrusivePtr<Val> reply;
ValPtr reply;
BifEnum::MOUNT3::status_t mount_status = BifEnum::MOUNT3::MNT3_OK;
bool rpc_success = ( rpc_status == BifEnum::RPC_SUCCESS );
@ -203,14 +203,14 @@ zeek::Args MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
return vl;
}
zeek::IntrusivePtr<EnumVal> MOUNT_Interp::mount3_auth_flavor(const u_char*& buf, int& n)
EnumValPtr MOUNT_Interp::mount3_auth_flavor(const u_char*& buf, int& n)
{
BifEnum::MOUNT3::auth_flavor_t t = (BifEnum::MOUNT3::auth_flavor_t)extract_XDR_uint32(buf, n);
auto rval = zeek::BifType::Enum::MOUNT3::auth_flavor_t->GetVal(t);
return rval;
}
zeek::IntrusivePtr<StringVal> MOUNT_Interp::mount3_fh(const u_char*& buf, int& n)
StringValPtr MOUNT_Interp::mount3_fh(const u_char*& buf, int& n)
{
int fh_n;
const u_char* fh = extract_XDR_opaque(buf, n, fh_n, 64);
@ -221,7 +221,7 @@ zeek::IntrusivePtr<StringVal> MOUNT_Interp::mount3_fh(const u_char*& buf, int& n
return zeek::make_intrusive<StringVal>(new BroString(fh, fh_n, false));
}
zeek::IntrusivePtr<StringVal> MOUNT_Interp::mount3_filename(const u_char*& buf, int& n)
StringValPtr MOUNT_Interp::mount3_filename(const u_char*& buf, int& n)
{
int name_len;
const u_char* name = extract_XDR_opaque(buf, n, name_len);
@ -232,15 +232,15 @@ zeek::IntrusivePtr<StringVal> MOUNT_Interp::mount3_filename(const u_char*& buf,
return zeek::make_intrusive<StringVal>(new BroString(name, name_len, false));
}
zeek::IntrusivePtr<RecordVal> MOUNT_Interp::mount3_dirmntargs(const u_char*& buf, int& n)
RecordValPtr MOUNT_Interp::mount3_dirmntargs(const u_char*& buf, int& n)
{
auto dirmntargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::MOUNT3::dirmntargs_t);
dirmntargs->Assign(0, mount3_filename(buf, n));
return dirmntargs;
}
zeek::IntrusivePtr<RecordVal> MOUNT_Interp::mount3_mnt_reply(const u_char*& buf, int& n,
BifEnum::MOUNT3::status_t status)
RecordValPtr MOUNT_Interp::mount3_mnt_reply(const u_char*& buf, int& n,
BifEnum::MOUNT3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::MOUNT3::mnt_reply_t);

10
src/analyzer/protocol/rpc/MOUNT.h
View file

@ -29,12 +29,12 @@ protected:
// to 0. However, the methods might still return an allocated Val * !
// So, you might want to Unref() the Val if buf is 0. Method names
// are based on the type names of RFC 1813.
zeek::IntrusivePtr<EnumVal> mount3_auth_flavor(const u_char*& buf, int& n);
zeek::IntrusivePtr<StringVal> mount3_fh(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> mount3_dirmntargs(const u_char*&buf, int &n);
zeek::IntrusivePtr<StringVal> mount3_filename(const u_char*& buf, int& n);
EnumValPtr mount3_auth_flavor(const u_char*& buf, int& n);
StringValPtr mount3_fh(const u_char*& buf, int& n);
RecordValPtr mount3_dirmntargs(const u_char*&buf, int &n);
StringValPtr mount3_filename(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> mount3_mnt_reply(const u_char*& buf, int& n, BifEnum::MOUNT3::status_t status);
RecordValPtr mount3_mnt_reply(const u_char*& buf, int& n, BifEnum::MOUNT3::status_t status);
};
class MOUNT_Analyzer : public RPC_Analyzer {

76
src/analyzer/protocol/rpc/NFS.cc
View file

@ -22,7 +22,7 @@ bool NFS_Interp::RPC_BuildCall(RPC_CallInfo* c, const u_char*& buf, int& n)
uint32_t proc = c->Proc();
// The call arguments, depends on the call type obviously ...
zeek::IntrusivePtr<Val> callarg;
ValPtr callarg;
switch ( proc ) {
case BifEnum::NFS3::PROC_NULL:
@ -124,7 +124,7 @@ bool NFS_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_status,
double last_time, int reply_len)
{
EventHandlerPtr event = nullptr;
zeek::IntrusivePtr<Val> reply;
ValPtr reply;
BifEnum::NFS3::status_t nfs_status = BifEnum::NFS3::NFS3ERR_OK;
bool rpc_success = ( rpc_status == BifEnum::RPC_SUCCESS );
@ -278,7 +278,7 @@ bool NFS_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_status,
return true;
}
zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_file_data(const u_char*& buf, int& n, uint64_t offset, int size)
StringValPtr NFS_Interp::nfs3_file_data(const u_char*& buf, int& n, uint64_t offset, int size)
{
int data_n;
@ -336,7 +336,7 @@ zeek::Args NFS_Interp::event_common_vl(RPC_CallInfo *c, BifEnum::rpc_status rpc_
return vl;
}
zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_fh(const u_char*& buf, int& n)
StringValPtr NFS_Interp::nfs3_fh(const u_char*& buf, int& n)
{
int fh_n;
const u_char* fh = extract_XDR_opaque(buf, n, fh_n, 64);
@ -348,7 +348,7 @@ zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_fh(const u_char*& buf, int& n)
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattr(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_sattr(const u_char*& buf, int& n)
{
auto attrs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::sattr_t);
@ -379,7 +379,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattr(const u_char*& buf, int& n)
return attrs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattr_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_sattr_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::sattr_reply_t);
@ -397,7 +397,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattr_reply(const u_char*& buf, i
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_fattr(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_fattr(const u_char*& buf, int& n)
{
auto attrs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::fattr_t);
@ -419,21 +419,21 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_fattr(const u_char*& buf, int& n)
return attrs;
}
zeek::IntrusivePtr<EnumVal> NFS_Interp::nfs3_time_how(const u_char*& buf, int& n)
EnumValPtr NFS_Interp::nfs3_time_how(const u_char*& buf, int& n)
{
BifEnum::NFS3::time_how_t t = (BifEnum::NFS3::time_how_t)extract_XDR_uint32(buf, n);
auto rval = zeek::BifType::Enum::NFS3::time_how_t->GetVal(t);
return rval;
}
zeek::IntrusivePtr<EnumVal> NFS_Interp::nfs3_ftype(const u_char*& buf, int& n)
EnumValPtr NFS_Interp::nfs3_ftype(const u_char*& buf, int& n)
{
BifEnum::NFS3::file_type_t t = (BifEnum::NFS3::file_type_t)extract_XDR_uint32(buf, n);
auto rval = zeek::BifType::Enum::NFS3::file_type_t->GetVal(t);
return rval;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_wcc_attr(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_wcc_attr(const u_char*& buf, int& n)
{
auto attrs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::wcc_attr_t);
@ -444,7 +444,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_wcc_attr(const u_char*& buf, int&
return attrs;
}
zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_filename(const u_char*& buf, int& n)
StringValPtr NFS_Interp::nfs3_filename(const u_char*& buf, int& n)
{
int name_len;
const u_char* name = extract_XDR_opaque(buf, n, name_len);
@ -455,7 +455,7 @@ zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_filename(const u_char*& buf, int&
return zeek::make_intrusive<StringVal>(new BroString(name, name_len, false));
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_diropargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_diropargs(const u_char*& buf, int& n)
{
auto diropargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::diropargs_t);
@ -465,7 +465,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_diropargs(const u_char*& buf, int
return diropargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_symlinkdata(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_symlinkdata(const u_char*& buf, int& n)
{
auto symlinkdata = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::symlinkdata_t);
@ -475,7 +475,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_symlinkdata(const u_char*& buf, i
return symlinkdata;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_renameopargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_renameopargs(const u_char*& buf, int& n)
{
auto renameopargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::renameopargs_t);
@ -487,7 +487,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_renameopargs(const u_char*& buf,
return renameopargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_post_op_attr(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_post_op_attr(const u_char*& buf, int& n)
{
int have_attrs = extract_XDR_uint32(buf, n);
@ -497,7 +497,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_post_op_attr(const u_char*& buf,
return nullptr;
}
zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_post_op_fh(const u_char*& buf, int& n)
StringValPtr NFS_Interp::nfs3_post_op_fh(const u_char*& buf, int& n)
{
int have_fh = extract_XDR_uint32(buf, n);
@ -507,7 +507,7 @@ zeek::IntrusivePtr<StringVal> NFS_Interp::nfs3_post_op_fh(const u_char*& buf, in
return nullptr;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_pre_op_attr(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_pre_op_attr(const u_char*& buf, int& n)
{
int have_attrs = extract_XDR_uint32(buf, n);
@ -516,14 +516,14 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_pre_op_attr(const u_char*& buf, i
return nullptr;
}
zeek::IntrusivePtr<EnumVal> NFS_Interp::nfs3_stable_how(const u_char*& buf, int& n)
EnumValPtr NFS_Interp::nfs3_stable_how(const u_char*& buf, int& n)
{
BifEnum::NFS3::stable_how_t stable = (BifEnum::NFS3::stable_how_t)extract_XDR_uint32(buf, n);
auto rval = zeek::BifType::Enum::NFS3::stable_how_t->GetVal(stable);
return rval;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_lookup_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_lookup_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::lookup_reply_t);
@ -542,7 +542,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_lookup_reply(const u_char*& buf,
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_readargs(const u_char*& buf, int& n)
{
auto readargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::readargs_t);
@ -553,7 +553,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readargs(const u_char*& buf, int&
return readargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_read_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status,
RecordValPtr NFS_Interp::nfs3_read_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status,
bro_uint_t offset)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::read_reply_t);
@ -576,7 +576,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_read_reply(const u_char*& buf, in
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readlink_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_readlink_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::readlink_reply_t);
@ -593,7 +593,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readlink_reply(const u_char*& buf
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_link_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_link_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::link_reply_t);
@ -609,7 +609,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_link_reply(const u_char*& buf, in
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_symlinkargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_symlinkargs(const u_char*& buf, int& n)
{
auto symlinkargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::symlinkargs_t);
@ -619,7 +619,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_symlinkargs(const u_char*& buf, i
return symlinkargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattrargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_sattrargs(const u_char*& buf, int& n)
{
auto sattrargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::sattrargs_t);
@ -629,7 +629,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_sattrargs(const u_char*& buf, int
return sattrargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_linkargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_linkargs(const u_char*& buf, int& n)
{
auto linkargs = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::linkargs_t);
@ -639,7 +639,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_linkargs(const u_char*& buf, int&
return linkargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_writeargs(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_writeargs(const u_char*& buf, int& n)
{
uint32_t bytes;
uint64_t offset;
@ -657,7 +657,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_writeargs(const u_char*& buf, int
return writeargs;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_write_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_write_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::write_reply_t);
@ -682,7 +682,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_write_reply(const u_char*& buf, i
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_newobj_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
RecordValPtr NFS_Interp::nfs3_newobj_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::newobj_reply_t);
@ -706,7 +706,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_newobj_reply(const u_char*& buf,
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_delobj_reply(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_delobj_reply(const u_char*& buf, int& n)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::delobj_reply_t);
@ -717,7 +717,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_delobj_reply(const u_char*& buf,
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_renameobj_reply(const u_char*& buf, int& n)
RecordValPtr NFS_Interp::nfs3_renameobj_reply(const u_char*& buf, int& n)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::renameobj_reply_t);
@ -730,7 +730,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_renameobj_reply(const u_char*& bu
return rep;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readdirargs(bool isplus, const u_char*& buf, int&n)
RecordValPtr NFS_Interp::nfs3_readdirargs(bool isplus, const u_char*& buf, int&n)
{
auto args = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::readdirargs_t);
@ -746,7 +746,7 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readdirargs(bool isplus, const u_
return args;
}
zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readdir_reply(bool isplus, const u_char*& buf,
RecordValPtr NFS_Interp::nfs3_readdir_reply(bool isplus, const u_char*& buf,
int&n, BifEnum::NFS3::status_t status)
{
auto rep = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::NFS3::readdir_reply_t);
@ -791,27 +791,27 @@ zeek::IntrusivePtr<RecordVal> NFS_Interp::nfs3_readdir_reply(bool isplus, const
return rep;
}
zeek::IntrusivePtr<Val> NFS_Interp::ExtractUint32(const u_char*& buf, int& n)
ValPtr NFS_Interp::ExtractUint32(const u_char*& buf, int& n)
{
return val_mgr->Count(extract_XDR_uint32(buf, n));
}
zeek::IntrusivePtr<Val> NFS_Interp::ExtractUint64(const u_char*& buf, int& n)
ValPtr NFS_Interp::ExtractUint64(const u_char*& buf, int& n)
{
return val_mgr->Count(extract_XDR_uint64(buf, n));
}
zeek::IntrusivePtr<Val> NFS_Interp::ExtractTime(const u_char*& buf, int& n)
ValPtr NFS_Interp::ExtractTime(const u_char*& buf, int& n)
{
return zeek::make_intrusive<TimeVal>(extract_XDR_time(buf, n));
}
zeek::IntrusivePtr<Val> NFS_Interp::ExtractInterval(const u_char*& buf, int& n)
ValPtr NFS_Interp::ExtractInterval(const u_char*& buf, int& n)
{
return zeek::make_intrusive<IntervalVal>(double(extract_XDR_uint32(buf, n)), 1.0);
}
zeek::IntrusivePtr<Val> NFS_Interp::ExtractBool(const u_char*& buf, int& n)
ValPtr NFS_Interp::ExtractBool(const u_char*& buf, int& n)
{
return val_mgr->Bool(extract_XDR_uint32(buf, n));
}

74
src/analyzer/protocol/rpc/NFS.h
View file

@ -30,53 +30,53 @@ protected:
// to 0. However, the methods might still return an allocated Val * !
// So, you might want to Unref() the Val if buf is 0. Method names
// are based on the type names of RFC 1813.
zeek::IntrusivePtr<StringVal> nfs3_fh(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_fattr(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_sattr(const u_char*& buf, int& n);
zeek::IntrusivePtr<EnumVal> nfs3_ftype(const u_char*& buf, int& n);
zeek::IntrusivePtr<EnumVal> nfs3_time_how(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_wcc_attr(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_diropargs(const u_char*&buf, int &n);
zeek::IntrusivePtr<RecordVal> nfs3_symlinkdata(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_renameopargs(const u_char*&buf, int &n);
zeek::IntrusivePtr<StringVal> nfs3_filename(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_linkargs(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_symlinkargs(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_sattrargs(const u_char*& buf, int& n);
zeek::IntrusivePtr<StringVal> nfs3_nfspath(const u_char*& buf, int& n)
StringValPtr nfs3_fh(const u_char*& buf, int& n);
RecordValPtr nfs3_fattr(const u_char*& buf, int& n);
RecordValPtr nfs3_sattr(const u_char*& buf, int& n);
EnumValPtr nfs3_ftype(const u_char*& buf, int& n);
EnumValPtr nfs3_time_how(const u_char*& buf, int& n);
RecordValPtr nfs3_wcc_attr(const u_char*& buf, int& n);
RecordValPtr nfs3_diropargs(const u_char*&buf, int &n);
RecordValPtr nfs3_symlinkdata(const u_char*& buf, int& n);
RecordValPtr nfs3_renameopargs(const u_char*&buf, int &n);
StringValPtr nfs3_filename(const u_char*& buf, int& n);
RecordValPtr nfs3_linkargs(const u_char*& buf, int& n);
RecordValPtr nfs3_symlinkargs(const u_char*& buf, int& n);
RecordValPtr nfs3_sattrargs(const u_char*& buf, int& n);
StringValPtr nfs3_nfspath(const u_char*& buf, int& n)
{
return nfs3_filename(buf,n);
}
zeek::IntrusivePtr<RecordVal> nfs3_post_op_attr(const u_char*&buf, int &n); // Return 0 or an fattr
zeek::IntrusivePtr<RecordVal> nfs3_pre_op_attr(const u_char*&buf, int &n); // Return 0 or an wcc_attr
zeek::IntrusivePtr<RecordVal> nfs3_sattr_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_lookup_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_readargs(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_read_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status, bro_uint_t offset);
zeek::IntrusivePtr<RecordVal> nfs3_readlink_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_link_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_writeargs(const u_char*& buf, int& n);
zeek::IntrusivePtr<EnumVal> nfs3_stable_how(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_write_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_newobj_reply(const u_char*& buf, int&n, BifEnum::NFS3::status_t status);
zeek::IntrusivePtr<RecordVal> nfs3_delobj_reply(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_renameobj_reply(const u_char*& buf, int& n);
zeek::IntrusivePtr<StringVal> nfs3_post_op_fh(const u_char*& buf, int& n);
zeek::IntrusivePtr<RecordVal> nfs3_readdirargs(bool isplus, const u_char*& buf, int&n);
zeek::IntrusivePtr<RecordVal> nfs3_readdir_reply(bool isplus, const u_char*& buf, int&n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_post_op_attr(const u_char*&buf, int &n); // Return 0 or an fattr
RecordValPtr nfs3_pre_op_attr(const u_char*&buf, int &n); // Return 0 or an wcc_attr
RecordValPtr nfs3_sattr_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_lookup_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_readargs(const u_char*& buf, int& n);
RecordValPtr nfs3_read_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status, bro_uint_t offset);
RecordValPtr nfs3_readlink_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_link_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_writeargs(const u_char*& buf, int& n);
EnumValPtr nfs3_stable_how(const u_char*& buf, int& n);
RecordValPtr nfs3_write_reply(const u_char*& buf, int& n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_newobj_reply(const u_char*& buf, int&n, BifEnum::NFS3::status_t status);
RecordValPtr nfs3_delobj_reply(const u_char*& buf, int& n);
RecordValPtr nfs3_renameobj_reply(const u_char*& buf, int& n);
StringValPtr nfs3_post_op_fh(const u_char*& buf, int& n);
RecordValPtr nfs3_readdirargs(bool isplus, const u_char*& buf, int&n);
RecordValPtr nfs3_readdir_reply(bool isplus, const u_char*& buf, int&n, BifEnum::NFS3::status_t status);
// Consumes the file data in the RPC message. Depending on NFS::return_data* consts
// in bro.init returns NULL or the data as string val:
// * offset is the offset of the read/write call
// * size is the amount of bytes read (or requested to be written),
zeek::IntrusivePtr<StringVal> nfs3_file_data(const u_char*& buf, int& n, uint64_t offset, int size);
StringValPtr nfs3_file_data(const u_char*& buf, int& n, uint64_t offset, int size);
zeek::IntrusivePtr<Val> ExtractUint32(const u_char*& buf, int& n);
zeek::IntrusivePtr<Val> ExtractUint64(const u_char*& buf, int& n);
zeek::IntrusivePtr<Val> ExtractTime(const u_char*& buf, int& n);
zeek::IntrusivePtr<Val> ExtractInterval(const u_char*& buf, int& n);
zeek::IntrusivePtr<Val> ExtractBool(const u_char*& buf, int& n);
ValPtr ExtractUint32(const u_char*& buf, int& n);
ValPtr ExtractUint64(const u_char*& buf, int& n);
ValPtr ExtractTime(const u_char*& buf, int& n);
ValPtr ExtractInterval(const u_char*& buf, int& n);
ValPtr ExtractBool(const u_char*& buf, int& n);
};
class NFS_Analyzer : public RPC_Analyzer {

10
src/analyzer/protocol/rpc/Portmap.cc
View file

@ -79,7 +79,7 @@ bool PortmapperInterp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status statu
int reply_len)
{
EventHandlerPtr event;
zeek::IntrusivePtr<Val> reply;
ValPtr reply;
int success = (status == BifEnum::RPC_SUCCESS);
switch ( c->Proc() ) {
@ -189,7 +189,7 @@ bool PortmapperInterp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status statu
return true;
}
zeek::IntrusivePtr<Val> PortmapperInterp::ExtractMapping(const u_char*& buf, int& len)
ValPtr PortmapperInterp::ExtractMapping(const u_char*& buf, int& len)
{
static auto pm_mapping = zeek::id::find_type<zeek::RecordType>("pm_mapping");
auto mapping = zeek::make_intrusive<RecordVal>(pm_mapping);
@ -207,7 +207,7 @@ zeek::IntrusivePtr<Val> PortmapperInterp::ExtractMapping(const u_char*& buf, int
return mapping;
}
zeek::IntrusivePtr<Val> PortmapperInterp::ExtractPortRequest(const u_char*& buf, int& len)
ValPtr PortmapperInterp::ExtractPortRequest(const u_char*& buf, int& len)
{
static auto pm_port_request = zeek::id::find_type<zeek::RecordType>("pm_port_request");
auto pr = zeek::make_intrusive<RecordVal>(pm_port_request);
@ -225,7 +225,7 @@ zeek::IntrusivePtr<Val> PortmapperInterp::ExtractPortRequest(const u_char*& buf,
return pr;
}
zeek::IntrusivePtr<Val> PortmapperInterp::ExtractCallItRequest(const u_char*& buf, int& len)
ValPtr PortmapperInterp::ExtractCallItRequest(const u_char*& buf, int& len)
{
static auto pm_callit_request = zeek::id::find_type<zeek::RecordType>("pm_callit_request");
auto c = zeek::make_intrusive<RecordVal>(pm_callit_request);
@ -262,7 +262,7 @@ uint32_t PortmapperInterp::CheckPort(uint32_t port)
return port;
}
void PortmapperInterp::Event(EventHandlerPtr f, zeek::IntrusivePtr<Val> request, BifEnum::rpc_status status, zeek::IntrusivePtr<Val> reply)
void PortmapperInterp::Event(EventHandlerPtr f, ValPtr request, BifEnum::rpc_status status, ValPtr reply)
{
if ( ! f )
return;

8
src/analyzer/protocol/rpc/Portmap.h
View file

@ -17,11 +17,11 @@ protected:
double last_time, int reply_len) override;
uint32_t CheckPort(uint32_t port);
void Event(EventHandlerPtr f, zeek::IntrusivePtr<Val> request, BifEnum::rpc_status status, zeek::IntrusivePtr<Val> reply);
void Event(EventHandlerPtr f, ValPtr request, BifEnum::rpc_status status, ValPtr reply);
zeek::IntrusivePtr<Val> ExtractMapping(const u_char*& buf, int& len);
zeek::IntrusivePtr<Val> ExtractPortRequest(const u_char*& buf, int& len);
zeek::IntrusivePtr<Val> ExtractCallItRequest(const u_char*& buf, int& len);
ValPtr ExtractMapping(const u_char*& buf, int& len);
ValPtr ExtractPortRequest(const u_char*& buf, int& len);
ValPtr ExtractCallItRequest(const u_char*& buf, int& len);
};
class Portmapper_Analyzer : public RPC_Analyzer {

8
src/analyzer/protocol/rpc/RPC.h
View file

@ -52,9 +52,9 @@ public:
double last_time, int rpc_len);
~RPC_CallInfo();
void AddVal(zeek::IntrusivePtr<Val> arg_v) { v = std::move(arg_v); }
const zeek::IntrusivePtr<Val>& RequestVal() const { return v; }
zeek::IntrusivePtr<Val> TakeRequestVal() { auto rv = std::move(v); return rv; }
void AddVal(ValPtr arg_v) { v = std::move(arg_v); }
const ValPtr& RequestVal() const { return v; }
ValPtr TakeRequestVal() { auto rv = std::move(v); return rv; }
bool CompareRexmit(const u_char* buf, int n) const;
@ -95,7 +95,7 @@ protected:
int header_len; // size of data before the arguments
bool valid_call; // whether call was well-formed
zeek::IntrusivePtr<Val> v; // single (perhaps compound) value corresponding to call
ValPtr v; // single (perhaps compound) value corresponding to call
};
class RPC_Interpreter {

4
src/analyzer/protocol/sip/sip-analyzer.pac
View file

@ -3,7 +3,7 @@ refine flow SIP_Flow += {
%member{
int content_length;
bool build_headers;
std::vector<zeek::IntrusivePtr<Val>> headers;
std::vector<ValPtr> headers;
%}
%init{
@ -104,7 +104,7 @@ refine flow SIP_Flow += {
%{
static auto mime_header_rec = zeek::id::find_type<zeek::RecordType>("mime_header_rec");
RecordVal* header_record = new RecordVal(mime_header_rec);
zeek::IntrusivePtr<StringVal> name_val;
StringValPtr name_val;
if ( name.length() > 0 )
{

16
src/analyzer/protocol/smb/smb-strings.pac
View file

@ -3,7 +3,7 @@
%}
%code{
zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::uint8s_to_stringval(std::vector<uint8_t>* data)
StringValPtr binpac::SMB::SMB_Conn::uint8s_to_stringval(std::vector<uint8_t>* data)
{
int length = data->size();
auto buf = std::make_unique<uint8[]>(length);
@ -15,7 +15,7 @@ zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::uint8s_to_stringval(std::ve
return utf16_to_utf8_val(bro_analyzer()->Conn(), bs);
}
zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::extract_string(SMB_string* s)
StringValPtr binpac::SMB::SMB_Conn::extract_string(SMB_string* s)
{
if ( s->unicode() == false )
{
@ -37,12 +37,12 @@ zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::extract_string(SMB_string*
return uint8s_to_stringval(s->u()->s());
}
zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::smb_string2stringval(SMB_string* s)
StringValPtr binpac::SMB::SMB_Conn::smb_string2stringval(SMB_string* s)
{
return extract_string(s);
}
zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::smb2_string2stringval(SMB2_string* s)
StringValPtr binpac::SMB::SMB_Conn::smb2_string2stringval(SMB2_string* s)
{
return uint8s_to_stringval(s->s());
}
@ -50,10 +50,10 @@ zeek::IntrusivePtr<StringVal> binpac::SMB::SMB_Conn::smb2_string2stringval(SMB2_
refine connection SMB_Conn += {
%member{
zeek::IntrusivePtr<StringVal> uint8s_to_stringval(std::vector<uint8_t>* data);
zeek::IntrusivePtr<StringVal> extract_string(SMB_string* s);
zeek::IntrusivePtr<StringVal> smb_string2stringval(SMB_string* s);
zeek::IntrusivePtr<StringVal> smb2_string2stringval(SMB2_string* s);
StringValPtr uint8s_to_stringval(std::vector<uint8_t>* data);
StringValPtr extract_string(SMB_string* s);
StringValPtr smb_string2stringval(SMB_string* s);
StringValPtr smb2_string2stringval(SMB2_string* s);
SMB_unicode_string* me;
%}

12
src/analyzer/protocol/smb/smb-time.pac
View file

@ -1,13 +1,13 @@
%header{
zeek::IntrusivePtr<Val> filetime2brotime(uint64_t ts);
zeek::IntrusivePtr<Val> time_from_lanman(SMB_time* t, SMB_date* d, uint16_t tz);
ValPtr filetime2brotime(uint64_t ts);
ValPtr time_from_lanman(SMB_time* t, SMB_date* d, uint16_t tz);
zeek::IntrusivePtr<RecordVal> SMB_BuildMACTimes(uint64_t modify, uint64_t access,
RecordValPtr SMB_BuildMACTimes(uint64_t modify, uint64_t access,
uint64_t create, uint64_t change);
%}
%code{
zeek::IntrusivePtr<Val> filetime2brotime(uint64_t ts)
ValPtr filetime2brotime(uint64_t ts)
{
// Bro can't support times back to the 1600's
// so we subtract a lot of seconds.
@ -15,7 +15,7 @@ zeek::IntrusivePtr<Val> filetime2brotime(uint64_t ts)
return zeek::make_intrusive<TimeVal>(secs);
}
zeek::IntrusivePtr<Val> time_from_lanman(SMB_time* t, SMB_date* d, uint16_t tz)
ValPtr time_from_lanman(SMB_time* t, SMB_date* d, uint16_t tz)
{
tm lTime;
lTime.tm_sec = ${t.two_seconds} * 2;
@ -29,7 +29,7 @@ zeek::IntrusivePtr<Val> time_from_lanman(SMB_time* t, SMB_date* d, uint16_t tz)
return zeek::make_intrusive<TimeVal>(lResult + tz);
}
zeek::IntrusivePtr<RecordVal> SMB_BuildMACTimes(uint64_t modify, uint64_t access,
RecordValPtr SMB_BuildMACTimes(uint64_t modify, uint64_t access,
uint64_t create, uint64_t change)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB::MACTimes);

2
src/analyzer/protocol/smb/smb1-com-transaction-secondary.pac
View file

@ -17,7 +17,7 @@ refine connection SMB_Conn += {
auto parameters = zeek::make_intrusive<StringVal>(${val.parameters}.length(),
(const char*)${val.parameters}.data());
zeek::IntrusivePtr<StringVal> payload_str;
StringValPtr payload_str;
SMB1_transaction_data* payload = nullptr;
if ( ${val.data_count} > 0 )

8
src/analyzer/protocol/smb/smb1-com-transaction.pac
View file

@ -5,7 +5,7 @@ enum Trans_subcommands {
};
%code{
zeek::IntrusivePtr<StringVal> SMB_Conn::transaction_data_to_val(SMB1_transaction_data* payload)
StringValPtr SMB_Conn::transaction_data_to_val(SMB1_transaction_data* payload)
{
switch ( payload->trans_type() ) {
case SMB_PIPE:
@ -26,7 +26,7 @@ refine connection SMB_Conn += {
%member{
map<uint16, bool> is_file_a_pipe;
static zeek::IntrusivePtr<StringVal> transaction_data_to_val(SMB1_transaction_data* payload);
static StringValPtr transaction_data_to_val(SMB1_transaction_data* payload);
%}
function get_is_file_a_pipe(id: uint16): bool
@ -55,7 +55,7 @@ refine connection SMB_Conn += {
auto parameters = zeek::make_intrusive<StringVal>(${val.parameters}.length(),
(const char*)${val.parameters}.data());
zeek::IntrusivePtr<StringVal> payload_str;
StringValPtr payload_str;
if ( ${val.data_count} > 0 )
payload_str = transaction_data_to_val(${val.data});
@ -80,7 +80,7 @@ refine connection SMB_Conn += {
auto parameters = zeek::make_intrusive<StringVal>(${val.parameters}.length(),
(const char*)${val.parameters}.data());
zeek::IntrusivePtr<StringVal> payload_str;
StringValPtr payload_str;
if ( ${val.data_count} > 0 )
payload_str = transaction_data_to_val(${val.data[0]});

4
src/analyzer/protocol/smb/smb1-protocol.pac
View file

@ -3,11 +3,11 @@
%}
%header{
zeek::IntrusivePtr<RecordVal> SMBHeaderVal(SMB_Header* hdr);
RecordValPtr SMBHeaderVal(SMB_Header* hdr);
%}
%code{
zeek::IntrusivePtr<RecordVal> SMBHeaderVal(SMB_Header* hdr)
RecordValPtr SMBHeaderVal(SMB_Header* hdr)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB1::Header);

16
src/analyzer/protocol/smb/smb2-protocol.pac
View file

@ -2,14 +2,14 @@
# http://msdn.microsoft.com/en-us/library/cc246497(v=PROT.13).aspx
%header{
zeek::IntrusivePtr<RecordVal> BuildSMB2HeaderVal(SMB2_Header* hdr);
zeek::IntrusivePtr<RecordVal> BuildSMB2GUID(SMB2_guid* file_id);
zeek::IntrusivePtr<RecordVal> smb2_file_attrs_to_bro(SMB2_file_attributes* val);
zeek::IntrusivePtr<RecordVal> BuildSMB2ContextVal(SMB3_negotiate_context_value* ncv);
RecordValPtr BuildSMB2HeaderVal(SMB2_Header* hdr);
RecordValPtr BuildSMB2GUID(SMB2_guid* file_id);
RecordValPtr smb2_file_attrs_to_bro(SMB2_file_attributes* val);
RecordValPtr BuildSMB2ContextVal(SMB3_negotiate_context_value* ncv);
%}
%code{
zeek::IntrusivePtr<RecordVal> BuildSMB2HeaderVal(SMB2_Header* hdr)
RecordValPtr BuildSMB2HeaderVal(SMB2_Header* hdr)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB2::Header);
r->Assign(0, val_mgr->Count(${hdr.credit_charge}));
@ -25,7 +25,7 @@ zeek::IntrusivePtr<RecordVal> BuildSMB2HeaderVal(SMB2_Header* hdr)
return r;
}
zeek::IntrusivePtr<RecordVal> BuildSMB2GUID(SMB2_guid* file_id)
RecordValPtr BuildSMB2GUID(SMB2_guid* file_id)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB2::GUID);
r->Assign(0, val_mgr->Count(${file_id.persistent}));
@ -33,7 +33,7 @@ zeek::IntrusivePtr<RecordVal> BuildSMB2GUID(SMB2_guid* file_id)
return r;
}
zeek::IntrusivePtr<RecordVal> smb2_file_attrs_to_bro(SMB2_file_attributes* val)
RecordValPtr smb2_file_attrs_to_bro(SMB2_file_attributes* val)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB2::FileAttrs);
r->Assign(0, val_mgr->Bool(${val.read_only}));
@ -54,7 +54,7 @@ zeek::IntrusivePtr<RecordVal> smb2_file_attrs_to_bro(SMB2_file_attributes* val)
return r;
}
zeek::IntrusivePtr<RecordVal> BuildSMB2ContextVal(SMB3_negotiate_context_value* ncv)
RecordValPtr BuildSMB2ContextVal(SMB3_negotiate_context_value* ncv)
{
auto r = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SMB2::NegotiateContextValue);

40
src/analyzer/protocol/snmp/snmp-analyzer.pac
View file

@ -8,26 +8,26 @@
%}
%header{
zeek::IntrusivePtr<AddrVal> network_address_to_val(const ASN1Encoding* na);
zeek::IntrusivePtr<AddrVal> network_address_to_val(const NetworkAddress* na);
zeek::IntrusivePtr<Val> asn1_obj_to_val(const ASN1Encoding* obj);
AddrValPtr network_address_to_val(const ASN1Encoding* na);
AddrValPtr network_address_to_val(const NetworkAddress* na);
ValPtr asn1_obj_to_val(const ASN1Encoding* obj);
zeek::IntrusivePtr<RecordVal> build_hdr(const Header* header);
zeek::IntrusivePtr<RecordVal> build_hdrV3(const Header* header);
zeek::IntrusivePtr<VectorVal> build_bindings(const VarBindList* vbl);
zeek::IntrusivePtr<RecordVal> build_pdu(const CommonPDU* pdu);
zeek::IntrusivePtr<RecordVal> build_trap_pdu(const TrapPDU* pdu);
zeek::IntrusivePtr<RecordVal> build_bulk_pdu(const GetBulkRequestPDU* pdu);
RecordValPtr build_hdr(const Header* header);
RecordValPtr build_hdrV3(const Header* header);
VectorValPtr build_bindings(const VarBindList* vbl);
RecordValPtr build_pdu(const CommonPDU* pdu);
RecordValPtr build_trap_pdu(const TrapPDU* pdu);
RecordValPtr build_bulk_pdu(const GetBulkRequestPDU* pdu);
%}
%code{
zeek::IntrusivePtr<AddrVal> network_address_to_val(const NetworkAddress* na)
AddrValPtr network_address_to_val(const NetworkAddress* na)
{
return network_address_to_val(na->encoding());
}
zeek::IntrusivePtr<AddrVal> network_address_to_val(const ASN1Encoding* na)
AddrValPtr network_address_to_val(const ASN1Encoding* na)
{
bytestring const& bs = na->content();
@ -42,9 +42,9 @@ zeek::IntrusivePtr<AddrVal> network_address_to_val(const ASN1Encoding* na)
return zeek::make_intrusive<AddrVal>(ntohl(network_order));
}
zeek::IntrusivePtr<Val> asn1_obj_to_val(const ASN1Encoding* obj)
ValPtr asn1_obj_to_val(const ASN1Encoding* obj)
{
zeek::IntrusivePtr<RecordVal> rval = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::ObjectValue);
RecordValPtr rval = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::ObjectValue);
uint8 tag = obj->meta()->tag();
rval->Assign(0, val_mgr->Count(tag));
@ -85,12 +85,12 @@ zeek::IntrusivePtr<Val> asn1_obj_to_val(const ASN1Encoding* obj)
return rval;
}
zeek::IntrusivePtr<Val> time_ticks_to_val(const TimeTicks* tt)
ValPtr time_ticks_to_val(const TimeTicks* tt)
{
return asn1_integer_to_val(tt->asn1_integer(), zeek::TYPE_COUNT);
}
zeek::IntrusivePtr<RecordVal> build_hdr(const Header* header)
RecordValPtr build_hdr(const Header* header)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::Header);
rv->Assign(0, val_mgr->Count(header->version()));
@ -122,7 +122,7 @@ zeek::IntrusivePtr<RecordVal> build_hdr(const Header* header)
return rv;
}
zeek::IntrusivePtr<RecordVal> build_hdrV3(const Header* header)
RecordValPtr build_hdrV3(const Header* header)
{
auto v3 = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::HeaderV3);
const v3Header* v3hdr = header->v3();
@ -151,7 +151,7 @@ zeek::IntrusivePtr<RecordVal> build_hdrV3(const Header* header)
return v3;
}
zeek::IntrusivePtr<VectorVal> build_bindings(const VarBindList* vbl)
VectorValPtr build_bindings(const VarBindList* vbl)
{
auto vv = zeek::make_intrusive<VectorVal>(zeek::BifType::Vector::SNMP::Bindings);
@ -167,7 +167,7 @@ zeek::IntrusivePtr<VectorVal> build_bindings(const VarBindList* vbl)
return vv;
}
zeek::IntrusivePtr<RecordVal> build_pdu(const CommonPDU* pdu)
RecordValPtr build_pdu(const CommonPDU* pdu)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::PDU);
rv->Assign(0, asn1_integer_to_val(pdu->request_id(), zeek::TYPE_INT));
@ -177,7 +177,7 @@ zeek::IntrusivePtr<RecordVal> build_pdu(const CommonPDU* pdu)
return rv;
}
zeek::IntrusivePtr<RecordVal> build_trap_pdu(const TrapPDU* pdu)
RecordValPtr build_trap_pdu(const TrapPDU* pdu)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::TrapPDU);
rv->Assign(0, asn1_oid_to_val(pdu->enterprise()));
@ -189,7 +189,7 @@ zeek::IntrusivePtr<RecordVal> build_trap_pdu(const TrapPDU* pdu)
return rv;
}
zeek::IntrusivePtr<RecordVal> build_bulk_pdu(const GetBulkRequestPDU* pdu)
RecordValPtr build_bulk_pdu(const GetBulkRequestPDU* pdu)
{
auto rv = zeek::make_intrusive<RecordVal>(zeek::BifType::Record::SNMP::BulkPDU);
rv->Assign(0, asn1_integer_to_val(pdu->request_id(), zeek::TYPE_INT));

4
src/analyzer/protocol/socks/socks-analyzer.pac
View file

@ -1,10 +1,10 @@
%header{
zeek::IntrusivePtr<StringVal> array_to_string(vector<uint8> *a);
StringValPtr array_to_string(vector<uint8> *a);
%}
%code{
zeek::IntrusivePtr<StringVal> array_to_string(vector<uint8> *a)
StringValPtr array_to_string(vector<uint8> *a)
{
int len = a->size();
auto tmp = std::make_unique<char[]>(len);

4
src/analyzer/protocol/ssh/ssh-analyzer.pac
View file

@ -5,12 +5,12 @@
%}
%header{
zeek::IntrusivePtr<VectorVal> name_list_to_vector(const bytestring& nl);
VectorValPtr name_list_to_vector(const bytestring& nl);
%}
%code{
// Copied from IRC_Analyzer::SplitWords
zeek::IntrusivePtr<VectorVal> name_list_to_vector(const bytestring& nl)
VectorValPtr name_list_to_vector(const bytestring& nl)
{
auto vv = zeek::make_intrusive<VectorVal>(zeek::id::string_vec);

Some files were not shown because too many files have changed in this diff Show more