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

Add deprecated version of EnumType::GetVal() to returns EnumVal*, rename IntrusivePtr version to GetEnumVal

Browse source
This commit is contained in:
Tim Wojtulewicz 2020-07-15 14:56:05 -07:00
parent fd8db24daf
commit 118605f4ac
24 changed files with 90 additions and 85 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/CompHash.cc
View file

@ -762,7 +762,7 @@ const char* CompositeHash::RecoverOneVal(
kp1 = reinterpret_cast<const char*>(kp+1);
if ( tag == zeek::TYPE_ENUM )
*pval = t->AsEnumType()->GetVal(*kp);
*pval = t->AsEnumType()->GetEnumVal(*kp);
else if ( tag == zeek::TYPE_BOOL )
*pval = zeek::val_mgr->Bool(*kp);
else if ( tag == zeek::TYPE_INT )

2
src/Stmt.cc
View file

@ -216,7 +216,7 @@ static EnumValPtr lookup_enum_val(const char* module_name, const char* name)
int index = et->Lookup(module_name, name);
assert(index >= 0);
return et->GetVal(index);
return et->GetEnumVal(index);
}
static void print_log(const std::vector<ValPtr>& vals)

4
src/Tag.cc
View file

@ -10,7 +10,7 @@ Tag::Tag(const zeek::EnumTypePtr& etype, type_t arg_type, subtype_t arg_subtype)
type = arg_type;
subtype = arg_subtype;
int64_t i = (int64_t)(type) | ((int64_t)subtype << 31);
val = etype->GetVal(i);
val = etype->GetEnumVal(i);
}
Tag::Tag(zeek::EnumType* etype, type_t arg_type, subtype_t arg_subtype)
@ -77,7 +77,7 @@ const zeek::EnumValPtr& Tag::AsVal(const zeek::EnumTypePtr& etype) const
if ( ! val )
{
assert(type == 0 && subtype == 0);
val = etype->GetVal(0);
val = etype->GetEnumVal(0);
}
return val;

2
src/TunnelEncapsulation.cc
View file

@ -26,7 +26,7 @@ zeek::RecordValPtr EncapsulatingConn::ToVal() const
id_val->Assign(2, zeek::make_intrusive<zeek::AddrVal>(dst_addr));
id_val->Assign(3, zeek::val_mgr->Port(ntohs(dst_port), proto));
rv->Assign(0, std::move(id_val));
rv->Assign(1, zeek::BifType::Enum::Tunnel::Type->GetVal(type));
rv->Assign(1, zeek::BifType::Enum::Tunnel::Type->GetEnumVal(type));
rv->Assign(2, zeek::make_intrusive<zeek::StringVal>(uid.Base62("C").c_str()));

2
src/Type.cc
View file

@ -1330,7 +1330,7 @@ EnumType::enum_name_list EnumType::Names() const
return n;
}
const EnumValPtr& EnumType::GetVal(bro_int_t i)
const EnumValPtr& EnumType::GetEnumVal(bro_int_t i)
{
auto it = vals.find(i);

8
src/Type.h
View file

@ -709,7 +709,13 @@ public:
void DescribeReST(ODesc* d, bool roles_only = false) const override;
const zeek::EnumValPtr& GetVal(bro_int_t i);
const zeek::EnumValPtr& GetEnumVal(bro_int_t i);
[[deprecated("Remove in v4.1. Use GetEnumVal() instead.")]]
zeek::EnumVal* GetVal(bro_int_t i)
{
return GetEnumVal(i).get();
}
protected:
void AddNameInternal(const std::string& module_name,

8
src/Val.cc
View file

@ -2096,16 +2096,16 @@ void TableVal::CallChangeFunc(const Val* index,
switch ( tpe )
{
case ELEMENT_NEW:
vl.emplace_back(BifType::Enum::TableChange->GetVal(BifEnum::TableChange::TABLE_ELEMENT_NEW));
vl.emplace_back(BifType::Enum::TableChange->GetEnumVal(BifEnum::TableChange::TABLE_ELEMENT_NEW));
break;
case ELEMENT_CHANGED:
vl.emplace_back(BifType::Enum::TableChange->GetVal(BifEnum::TableChange::TABLE_ELEMENT_CHANGED));
vl.emplace_back(BifType::Enum::TableChange->GetEnumVal(BifEnum::TableChange::TABLE_ELEMENT_CHANGED));
break;
case ELEMENT_REMOVED:
vl.emplace_back(BifType::Enum::TableChange->GetVal(BifEnum::TableChange::TABLE_ELEMENT_REMOVED));
vl.emplace_back(BifType::Enum::TableChange->GetEnumVal(BifEnum::TableChange::TABLE_ELEMENT_REMOVED));
break;
case ELEMENT_EXPIRED:
vl.emplace_back(BifType::Enum::TableChange->GetVal(BifEnum::TableChange::TABLE_ELEMENT_EXPIRED));
vl.emplace_back(BifType::Enum::TableChange->GetEnumVal(BifEnum::TableChange::TABLE_ELEMENT_EXPIRED));
}
for ( const auto& v : lv->Vals() )

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

@ -42,7 +42,7 @@ refine connection DCE_RPC_Conn += {
${header.is_orig},
fid,
${header.PTYPE},
zeek::BifType::Enum::DCE_RPC::PType->GetVal(${header.PTYPE}));
zeek::BifType::Enum::DCE_RPC::PType->GetEnumVal(${header.PTYPE}));
}
return true;
%}

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

@ -127,7 +127,7 @@ bool MOUNT_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_statu
// Otherwise DeliverRPC would complain about
// excess_RPC.
n = 0;
reply = zeek::BifType::Enum::MOUNT3::proc_t->GetVal(c->Proc());
reply = zeek::BifType::Enum::MOUNT3::proc_t->GetEnumVal(c->Proc());
event = mount_proc_not_implemented;
}
else
@ -185,8 +185,8 @@ zeek::Args MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
}
auto info = zeek::make_intrusive<zeek::RecordVal>(zeek::BifType::Record::MOUNT3::info_t);
info->Assign(0, zeek::BifType::Enum::rpc_status->GetVal(rpc_status));
info->Assign(1, zeek::BifType::Enum::MOUNT3::status_t->GetVal(mount_status));
info->Assign(0, zeek::BifType::Enum::rpc_status->GetEnumVal(rpc_status));
info->Assign(1, zeek::BifType::Enum::MOUNT3::status_t->GetEnumVal(mount_status));
info->Assign(2, zeek::make_intrusive<zeek::TimeVal>(c->StartTime()));
info->Assign(3, zeek::make_intrusive<zeek::IntervalVal>(c->LastTime() - c->StartTime()));
info->Assign(4, zeek::val_mgr->Count(c->RPCLen()));
@ -206,7 +206,7 @@ zeek::Args MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
zeek::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);
auto rval = zeek::BifType::Enum::MOUNT3::auth_flavor_t->GetEnumVal(t);
return rval;
}

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

@ -242,7 +242,7 @@ bool NFS_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_status,
// Otherwise DeliverRPC would complain about
// excess_RPC.
n = 0;
reply = zeek::BifType::Enum::NFS3::proc_t->GetVal(c->Proc());
reply = zeek::BifType::Enum::NFS3::proc_t->GetEnumVal(c->Proc());
event = nfs_proc_not_implemented;
}
else
@ -318,8 +318,8 @@ zeek::Args NFS_Interp::event_common_vl(RPC_CallInfo *c, BifEnum::rpc_status rpc_
auxgids->Assign(i, zeek::val_mgr->Count(c->AuxGIDs()[i]));
auto info = zeek::make_intrusive<zeek::RecordVal>(zeek::BifType::Record::NFS3::info_t);
info->Assign(0, zeek::BifType::Enum::rpc_status->GetVal(rpc_status));
info->Assign(1, zeek::BifType::Enum::NFS3::status_t->GetVal(nfs_status));
info->Assign(0, zeek::BifType::Enum::rpc_status->GetEnumVal(rpc_status));
info->Assign(1, zeek::BifType::Enum::NFS3::status_t->GetEnumVal(nfs_status));
info->Assign(2, zeek::make_intrusive<zeek::TimeVal>(c->StartTime()));
info->Assign(3, zeek::make_intrusive<zeek::IntervalVal>(c->LastTime()-c->StartTime()));
info->Assign(4, zeek::val_mgr->Count(c->RPCLen()));
@ -422,14 +422,14 @@ zeek::RecordValPtr NFS_Interp::nfs3_fattr(const u_char*& buf, int& n)
zeek::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);
auto rval = zeek::BifType::Enum::NFS3::time_how_t->GetEnumVal(t);
return rval;
}
zeek::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);
auto rval = zeek::BifType::Enum::NFS3::file_type_t->GetEnumVal(t);
return rval;
}
@ -519,7 +519,7 @@ zeek::RecordValPtr NFS_Interp::nfs3_pre_op_attr(const u_char*& buf, int& n)
zeek::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);
auto rval = zeek::BifType::Enum::NFS3::stable_how_t->GetEnumVal(stable);
return rval;
}

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

@ -280,7 +280,7 @@ void PortmapperInterp::Event(EventHandlerPtr f, zeek::ValPtr request, BifEnum::r
}
else
{
vl.emplace_back(zeek::BifType::Enum::rpc_status->GetVal(status));
vl.emplace_back(zeek::BifType::Enum::rpc_status->GetEnumVal(status));
if ( request )
vl.emplace_back(std::move(request));

4
src/analyzer/protocol/rpc/RPC.cc
View file

@ -341,7 +341,7 @@ void RPC_Interpreter::Event_RPC_Dialogue(RPC_CallInfo* c, BifEnum::rpc_status st
zeek::val_mgr->Count(c->Program()),
zeek::val_mgr->Count(c->Version()),
zeek::val_mgr->Count(c->Proc()),
zeek::BifType::Enum::rpc_status->GetVal(status),
zeek::BifType::Enum::rpc_status->GetEnumVal(status),
zeek::make_intrusive<zeek::TimeVal>(c->StartTime()),
zeek::val_mgr->Count(c->CallLen()),
zeek::val_mgr->Count(reply_len)
@ -367,7 +367,7 @@ void RPC_Interpreter::Event_RPC_Reply(uint32_t xid, BifEnum::rpc_status status,
analyzer->EnqueueConnEvent(rpc_reply,
analyzer->ConnVal(),
zeek::val_mgr->Count(xid),
zeek::BifType::Enum::rpc_status->GetVal(status),
zeek::BifType::Enum::rpc_status->GetEnumVal(status),
zeek::val_mgr->Count(reply_len)
);
}

32
src/broker/Data.cc
View file

@ -191,7 +191,7 @@ struct val_converter {
if ( i == -1 )
return nullptr;
auto rval = etype->GetVal(i);
auto rval = etype->GetEnumVal(i);
return rval;
}
@ -1035,72 +1035,72 @@ struct data_type_getter {
result_type operator()(broker::none)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::NONE);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::NONE);
}
result_type operator()(bool)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::BOOL);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::BOOL);
}
result_type operator()(uint64_t)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::COUNT);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::COUNT);
}
result_type operator()(int64_t)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::INT);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INT);
}
result_type operator()(double)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::DOUBLE);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::DOUBLE);
}
result_type operator()(const std::string&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::STRING);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::STRING);
}
result_type operator()(const broker::address&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::ADDR);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ADDR);
}
result_type operator()(const broker::subnet&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::SUBNET);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SUBNET);
}
result_type operator()(const broker::port&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::PORT);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::PORT);
}
result_type operator()(const broker::timestamp&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::TIME);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TIME);
}
result_type operator()(const broker::timespan&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::INTERVAL);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::INTERVAL);
}
result_type operator()(const broker::enum_value&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::ENUM);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::ENUM);
}
result_type operator()(const broker::set&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::SET);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::SET);
}
result_type operator()(const broker::table&)
{
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::TABLE);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::TABLE);
}
result_type operator()(const broker::vector&)
@ -1108,7 +1108,7 @@ struct data_type_getter {
// Note that Broker uses vectors to store record data, so there's
// no actual way to tell if this data was originally associated
// with a Bro record.
return zeek::BifType::Enum::Broker::DataType->GetVal(BifEnum::Broker::VECTOR);
return zeek::BifType::Enum::Broker::DataType->GetEnumVal(BifEnum::Broker::VECTOR);
}
};

2
src/broker/Manager.cc
View file

@ -1353,7 +1353,7 @@ void Manager::ProcessError(broker::error err)
}
mgr.Enqueue(Broker::error,
zeek::BifType::Enum::Broker::ErrorCode->GetVal(ec),
zeek::BifType::Enum::Broker::ErrorCode->GetEnumVal(ec),
zeek::make_intrusive<zeek::StringVal>(msg)
);
}

2
src/broker/Store.cc
View file

@ -20,7 +20,7 @@ zeek::EnumValPtr query_status(bool success)
failure_val = store_query_status->Lookup("Broker", "FAILURE");
}
auto rval = store_query_status->GetVal(success ? success_val : failure_val);
auto rval = store_query_status->GetEnumVal(success ? success_val : failure_val);
return rval;
}

2
src/broker/comm.bif
View file

@ -123,7 +123,7 @@ function Broker::__peers%(%): PeerInfos
auto ps = (BifEnum::Broker::PeerStatus)p.status;
peer_info->Assign(0, std::move(endpoint_info));
peer_info->Assign(1, zeek::BifType::Enum::Broker::PeerStatus->GetVal(ps));
peer_info->Assign(1, zeek::BifType::Enum::Broker::PeerStatus->GetEnumVal(ps));
rval->Assign(i, std::move(peer_info));
++i;

36
src/input/Manager.cc
View file

@ -1065,7 +1065,7 @@ void Manager::SendEntry(ReaderFrontend* reader, Value* *vals)
else if ( i->stream_type == EVENT_STREAM )
{
auto type = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
readFields = SendEventStreamEvent(i, type.release(), vals);
}
@ -1170,9 +1170,9 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals)
if ( ! pred_convert_error )
{
if ( updated )
ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_CHANGED);
ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED);
else
ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
bool result;
if ( stream->num_val_fields > 0 ) // we have values
@ -1270,13 +1270,13 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals)
else if ( updated )
{ // in case of update send back the old value.
assert ( stream->num_val_fields > 0 );
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_CHANGED);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED);
assert ( oldval != nullptr );
SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), predidx, oldval.release());
}
else
{
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
if ( stream->num_val_fields == 0 )
{
Ref(stream->description);
@ -1338,7 +1338,7 @@ void Manager::EndCurrentSend(ReaderFrontend* reader)
val = stream->tab->FindOrDefault(idx);
assert(val != nullptr);
predidx = {zeek::AdoptRef{}, ListValToRecordVal(idx.get(), stream->itype, &startpos)};
ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_REMOVED);
ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED);
}
if ( stream->pred )
@ -1432,7 +1432,7 @@ void Manager::Put(ReaderFrontend* reader, Value* *vals)
else if ( i->stream_type == EVENT_STREAM )
{
auto type = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
readFields = SendEventStreamEvent(i, type.release(), vals);
}
@ -1569,9 +1569,9 @@ int Manager::PutTable(Stream* i, const Value* const *vals)
else
{
if ( updated )
ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_CHANGED);
ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED);
else
ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
bool result;
if ( stream->num_val_fields > 0 ) // we have values
@ -1609,14 +1609,14 @@ int Manager::PutTable(Stream* i, const Value* const *vals)
{
// in case of update send back the old value.
assert ( stream->num_val_fields > 0 );
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_CHANGED);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_CHANGED);
assert ( oldval != nullptr );
SendEvent(stream->event, 4, stream->description->Ref(),
ev.release(), predidx, oldval.release());
}
else
{
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_NEW);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_NEW);
if ( stream->num_val_fields == 0 )
SendEvent(stream->event, 4, stream->description->Ref(),
ev.release(), predidx);
@ -1701,7 +1701,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals)
Unref(predidx);
else
{
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_REMOVED);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED);
streamresult = CallPred(stream->pred, 3, ev.release(), predidx, zeek::IntrusivePtr{val}.release());
@ -1720,7 +1720,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals)
{
Ref(idxval);
assert(val != nullptr);
auto ev = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_REMOVED);
auto ev = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED);
SendEvent(stream->event, 4, stream->description->Ref(), ev.release(), idxval, zeek::IntrusivePtr{val}.release());
}
}
@ -1735,7 +1735,7 @@ bool Manager::Delete(ReaderFrontend* reader, Value* *vals)
else if ( i->stream_type == EVENT_STREAM )
{
auto type = zeek::BifType::Enum::Input::Event->GetVal(BifEnum::Input::EVENT_REMOVED);
auto type = zeek::BifType::Enum::Input::Event->GetEnumVal(BifEnum::Input::EVENT_REMOVED);
readVals = SendEventStreamEvent(i, type.release(), vals);
success = true;
}
@ -2306,7 +2306,7 @@ zeek::Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::Type* re
return nullptr;
}
auto rval = request_type->AsEnumType()->GetVal(index);
auto rval = request_type->AsEnumType()->GetEnumVal(index);
return rval.release();
}
@ -2439,15 +2439,15 @@ void Manager::ErrorHandler(const Stream* i, ErrorType et, bool reporter_send, co
switch (et)
{
case ErrorType::INFO:
ev = zeek::BifType::Enum::Reporter::Level->GetVal(BifEnum::Reporter::INFO);
ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::INFO);
break;
case ErrorType::WARNING:
ev = zeek::BifType::Enum::Reporter::Level->GetVal(BifEnum::Reporter::WARNING);
ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::WARNING);
break;
case ErrorType::ERROR:
ev = zeek::BifType::Enum::Reporter::Level->GetVal(BifEnum::Reporter::ERROR);
ev = zeek::BifType::Enum::Reporter::Level->GetEnumVal(BifEnum::Reporter::ERROR);
break;
default:

6
src/iosource/Packet.cc
View file

@ -626,7 +626,7 @@ zeek::RecordValPtr Packet::ToRawPktHdrVal() const
{
// Ethernet header layout is:
// dst[6bytes] src[6bytes] ethertype[2bytes]...
l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetVal(BifEnum::LINK_ETHERNET));
l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_ETHERNET));
l2_hdr->Assign(3, FmtEUI48(data + 6)); // src
l2_hdr->Assign(4, FmtEUI48(data)); // dst
@ -643,12 +643,12 @@ zeek::RecordValPtr Packet::ToRawPktHdrVal() const
l3 = BifEnum::L3_ARP;
}
else
l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetVal(BifEnum::LINK_UNKNOWN));
l2_hdr->Assign(0, zeek::BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_UNKNOWN));
l2_hdr->Assign(1, zeek::val_mgr->Count(len));
l2_hdr->Assign(2, zeek::val_mgr->Count(cap_len));
l2_hdr->Assign(8, zeek::BifType::Enum::layer3_proto->GetVal(l3));
l2_hdr->Assign(8, zeek::BifType::Enum::layer3_proto->GetEnumVal(l3));
pkt_hdr->Assign(0, std::move(l2_hdr));

2
src/logging/Manager.cc
View file

@ -1307,7 +1307,7 @@ void Manager::SendAllWritersTo(const broker::endpoint_info& ei)
i != stream->writers.end(); i++ )
{
WriterFrontend* writer = i->second->writer;
const auto& writer_val = et->GetVal(i->first.first);
const auto& writer_val = et->GetEnumVal(i->first.first);
broker_mgr->PublishLogCreate((*s)->id,
writer_val.get(),
*i->second->info,

3
src/logging/writers/ascii/Ascii.cc
View file

@ -764,7 +764,7 @@ void Ascii::RotateLeftoverLogs()
static auto rot_info_type = zeek::id::find_type<zeek::RecordType>("Log::RotationInfo");
static auto writer_type = zeek::id::find_type<zeek::EnumType>("Log::Writer");
static auto writer_idx = writer_type->Lookup("Log", "WRITER_ASCII");
static auto writer_val = writer_type->GetVal(writer_idx);
static auto writer_val = writer_type->GetEnumVal(writer_idx);
static auto default_ppf = zeek::id::find_func("Log::__default_rotation_postprocessor");
assert(default_ppf);
@ -908,4 +908,3 @@ bool Ascii::InternalClose(int fd)
return false;
}

2
src/parse.y
View file

@ -695,7 +695,7 @@ expr:
auto intval = t->Lookup(id->ModuleName(), id->Name());
if ( intval < 0 )
reporter->InternalError("enum value not found for %s", id->Name());
$$ = new zeek::detail::ConstExpr(t->GetVal(intval));
$$ = new zeek::detail::ConstExpr(t->GetEnumVal(intval));
}
else
{

12
src/supervisor/Supervisor.cc
View file

@ -1386,7 +1386,7 @@ RecordValPtr Supervisor::NodeConfig::ToRecord() const
const auto& ept = zeek::BifType::Record::Supervisor::ClusterEndpoint;
auto val = zeek::make_intrusive<zeek::RecordVal>(ept);
val->Assign(ept->FieldOffset("role"), zeek::BifType::Enum::Supervisor::ClusterRole->GetVal(ep.role));
val->Assign(ept->FieldOffset("role"), zeek::BifType::Enum::Supervisor::ClusterRole->GetEnumVal(ep.role));
val->Assign(ept->FieldOffset("host"), zeek::make_intrusive<zeek::AddrVal>(ep.host));
val->Assign(ept->FieldOffset("p"), zeek::val_mgr->Port(ep.port, TRANSPORT_TCP));
@ -1419,15 +1419,15 @@ static ValPtr supervisor_role_to_cluster_node_type(BifEnum::Supervisor::ClusterR
switch ( role ) {
case BifEnum::Supervisor::LOGGER:
return node_type->GetVal(node_type->Lookup("Cluster", "LOGGER"));
return node_type->GetEnumVal(node_type->Lookup("Cluster", "LOGGER"));
case BifEnum::Supervisor::MANAGER:
return node_type->GetVal(node_type->Lookup("Cluster", "MANAGER"));
return node_type->GetEnumVal(node_type->Lookup("Cluster", "MANAGER"));
case BifEnum::Supervisor::PROXY:
return node_type->GetVal(node_type->Lookup("Cluster", "PROXY"));
return node_type->GetEnumVal(node_type->Lookup("Cluster", "PROXY"));
case BifEnum::Supervisor::WORKER:
return node_type->GetVal(node_type->Lookup("Cluster", "WORKER"));
return node_type->GetEnumVal(node_type->Lookup("Cluster", "WORKER"));
default:
return node_type->GetVal(node_type->Lookup("Cluster", "NONE"));
return node_type->GetEnumVal(node_type->Lookup("Cluster", "NONE"));
}
}

2
src/threading/SerialTypes.cc
View file

@ -629,7 +629,7 @@ zeek::Val* Value::ValueToVal(const std::string& source, const Value* val, bool&
return nullptr;
}
auto rval = t->GetVal(intval);
auto rval = t->GetEnumVal(intval);
return rval.release();
}

18
src/zeek.bif
View file

@ -3253,16 +3253,16 @@ static zeek::EnumValPtr map_conn_type(TransportProto tp)
{
switch ( tp ) {
case TRANSPORT_UNKNOWN:
return zeek::id::transport_proto->GetVal(0);
return zeek::id::transport_proto->GetEnumVal(0);
case TRANSPORT_TCP:
return zeek::id::transport_proto->GetVal(1);
return zeek::id::transport_proto->GetEnumVal(1);
case TRANSPORT_UDP:
return zeek::id::transport_proto->GetVal(2);
return zeek::id::transport_proto->GetEnumVal(2);
case TRANSPORT_ICMP:
return zeek::id::transport_proto->GetVal(3);
return zeek::id::transport_proto->GetEnumVal(3);
default:
reporter->InternalError("bad connection type in map_conn_type()");
@ -3288,7 +3288,7 @@ function get_conn_transport_proto%(cid: conn_id%): transport_proto
if ( ! c )
{
zeek::emit_builtin_error("unknown connection id in get_conn_transport_proto()", cid);
return zeek::id::transport_proto->GetVal(0);
return zeek::id::transport_proto->GetEnumVal(0);
}
return map_conn_type(c->ConnTransport());
@ -3436,7 +3436,7 @@ function get_current_packet%(%) : pcap_packet
pkt->Assign(2, zeek::val_mgr->Count(0));
pkt->Assign(3, zeek::val_mgr->Count(0));
pkt->Assign(4, zeek::val_mgr->EmptyString());
pkt->Assign(5, zeek::BifType::Enum::link_encap->GetVal(BifEnum::LINK_UNKNOWN));
pkt->Assign(5, zeek::BifType::Enum::link_encap->GetEnumVal(BifEnum::LINK_UNKNOWN));
return pkt;
}
@ -3445,7 +3445,7 @@ function get_current_packet%(%) : pcap_packet
pkt->Assign(2, zeek::val_mgr->Count(p->cap_len));
pkt->Assign(3, zeek::val_mgr->Count(p->len));
pkt->Assign(4, zeek::make_intrusive<zeek::StringVal>(p->cap_len, (const char*)p->data));
pkt->Assign(5, zeek::BifType::Enum::link_encap->GetVal(p->link_type));
pkt->Assign(5, zeek::BifType::Enum::link_encap->GetEnumVal(p->link_type));
return pkt;
%}
@ -3945,7 +3945,7 @@ static zeek::ValPtr mmdb_getvalue(MMDB_entry_data_s* entry_data, int status,
static bool mmdb_try_open_loc ()
{
// City database is always preferred over Country database.
const auto& mmdb_dir_val = zeek::detail::global_scope()->Find("mmdb_dir")->GetVal();
const auto& mmdb_dir_val = zeek::detail::global_scope()->Find("mmdb_dir")->GetEnumVal();
std::string mmdb_dir = mmdb_dir_val->AsString()->CheckString();
if ( ! mmdb_dir.empty() )
@ -3973,7 +3973,7 @@ static bool mmdb_try_open_loc ()
static bool mmdb_try_open_asn ()
{
const auto& mmdb_dir_val = zeek::detail::global_scope()->Find("mmdb_dir")->GetVal();
const auto& mmdb_dir_val = zeek::detail::global_scope()->Find("mmdb_dir")->GetEnumVal();
std::string mmdb_dir = mmdb_dir_val->AsString()->CheckString();
if ( ! mmdb_dir.empty() )