diff --git a/NEWS b/NEWS index 16569dbb8e..c7c9c6bc3e 100644 --- a/NEWS +++ b/NEWS @@ -211,6 +211,9 @@ Deprecated Functionality - ``TableVal::Lookup()`` is deprecated, use ``TableVal::Find()`` or ``TableVal::FindOrDefault()``. +- ``VectorVal::Assign`` methods taking raw ``Val*`` are deprecated, use the + methods that take ``IntrusivePtr``. + Zeek 3.1.0 ========== diff --git a/src/BroString.cc b/src/BroString.cc index 2fe950b87d..15c7f6a773 100644 --- a/src/BroString.cc +++ b/src/BroString.cc @@ -345,9 +345,9 @@ VectorVal* BroString:: VecToPolicy(Vec* vec) for ( unsigned int i = 0; i < vec->size(); ++i ) { BroString* string = (*vec)[i]; - StringVal* val = new StringVal(string->Len(), - (const char*) string->Bytes()); - result->Assign(i+1, val); + auto val = make_intrusive(string->Len(), + (const char*) string->Bytes()); + result->Assign(i+1, std::move(val)); } return result.release(); diff --git a/src/Expr.cc b/src/Expr.cc index 27594c23e2..33c26f3e35 100644 --- a/src/Expr.cc +++ b/src/Expr.cc @@ -1572,7 +1572,7 @@ IntrusivePtr BoolExpr::Eval(Frame* f) const { result = make_intrusive(GetType()); result->Resize(vector_v->Size()); - result->AssignRepeat(0, result->Size(), scalar_v.get()); + result->AssignRepeat(0, result->Size(), std::move(scalar_v)); } else result = std::move(vector_v); @@ -1937,7 +1937,7 @@ IntrusivePtr CondExpr::Eval(Frame* f) const if ( local_cond ) { Val* v = local_cond->IsZero() ? b->Lookup(i) : a->Lookup(i); - result->Assign(i, v ? v->Ref() : nullptr); + result->Assign(i, v ? IntrusivePtr{NewRef{}, v} : nullptr); } else result->Assign(i, nullptr); @@ -2595,7 +2595,7 @@ IntrusivePtr IndexExpr::Eval(Frame* f) const if ( v_v2->Lookup(i)->AsBool() ) { auto a = v_v1->Lookup(i); - v_result->Assign(v_result->Size() + 1, a ? a->Ref() : nullptr); + v_result->Assign(v_result->Size() + 1, a ? IntrusivePtr{NewRef{}, a} : nullptr); } } } @@ -2608,7 +2608,7 @@ IntrusivePtr IndexExpr::Eval(Frame* f) const for ( unsigned int i = 0; i < v_v2->Size(); ++i ) { auto a = v_v1->Lookup(v_v2->Lookup(i)->CoerceToInt()); - v_result->Assign(i, a ? a->Ref() : nullptr); + v_result->Assign(i, a ? IntrusivePtr{NewRef{}, a} : nullptr); } } @@ -2659,7 +2659,7 @@ IntrusivePtr IndexExpr::Fold(Val* v1, Val* v2) const for ( int idx = first; idx < last; idx++ ) { auto a = vect->Lookup(idx); - result->Assign(idx - first, a ? a->Ref() : nullptr); + result->Assign(idx - first, a ? IntrusivePtr{NewRef{}, a} : nullptr); } } @@ -2758,7 +2758,7 @@ void IndexExpr::Assign(Frame* f, IntrusivePtr v) for ( auto idx = 0u; idx < v_vect->Size(); idx++, first++ ) v1_vect->Insert(first, v_vect->Lookup(idx)->Ref()); } - else if ( ! v1_vect->Assign(v2.get(), std::move(v)) ) + else if ( ! v1_vect->Assign(lv->Idx(0)->CoerceToUnsigned(), std::move(v)) ) { v = std::move(v_extra); diff --git a/src/Val.cc b/src/Val.cc index bc7fd36d91..bf2966dca1 100644 --- a/src/Val.cc +++ b/src/Val.cc @@ -3080,18 +3080,13 @@ bool VectorVal::Assign(unsigned int index, IntrusivePtr element) return true; } -bool VectorVal::Assign(unsigned int index, Val* element) - { - return Assign(index, {AdoptRef{}, element}); - } - bool VectorVal::AssignRepeat(unsigned int index, unsigned int how_many, - Val* element) + IntrusivePtr element) { ResizeAtLeast(index + how_many); for ( unsigned int i = index; i < index + how_many; ++i ) - if ( ! Assign(i, {NewRef{}, element}) ) + if ( ! Assign(i, element) ) return false; return true; diff --git a/src/Val.h b/src/Val.h index 8bf278943d..bf3541c02d 100644 --- a/src/Val.h +++ b/src/Val.h @@ -1245,25 +1245,44 @@ public: IntrusivePtr SizeVal() const override; - // Returns false if the type of the argument was wrong. - // The vector will automatically grow to accomodate the index. - // + /** + * Assigns an element to a given vector index. + * @param index The index to assign. + * @param element The element value to assign. + * @return True if the element was successfully assigned, or false if + * the element was the wrong type. + */ + bool Assign(unsigned int index, IntrusivePtr element); + // Note: does NOT Ref() the element! Remember to do so unless // the element was just created and thus has refcount 1. - // - bool Assign(unsigned int index, IntrusivePtr element); - bool Assign(unsigned int index, Val* element); + [[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]] + bool Assign(unsigned int index, Val* element) + { return Assign(index, {AdoptRef{}, element}); } + // Note: the following nullptr method can also go upon removing the above. + void Assign(unsigned int index, std::nullptr_t) + { Assign(index, IntrusivePtr{}); } - template - bool Assign(Val* index, E&& element) + [[deprecated("Remove in v4.1. Assign using integer index and IntrusivePtr element.")]] + bool Assign(Val* index, Val* element) { return Assign(index->AsListVal()->Idx(0)->CoerceToUnsigned(), - std::forward(element)); + {AdoptRef{}, element}); } - // Assigns the value to how_many locations starting at index. + /** + * Assigns a given value to multiple indices in the vector. + * @param index The starting index to assign to. + * @param how_many The number of indices to assign, counting from *index*. + * @return True if the elements were successfully assigned, or false if + * the element was the wrong type. + */ bool AssignRepeat(unsigned int index, unsigned int how_many, - Val* element); + IntrusivePtr element); + + [[deprecated("Remove in v4.1. Assign an IntrusivePtr instead.")]] + bool AssignRepeat(unsigned int index, unsigned int how_many, Val* element) + { return AssignRepeat(index, how_many, {NewRef{}, element}); } // Add this value to the given value (if appropriate). // Returns true if succcessful. diff --git a/src/analyzer/protocol/dhcp/dhcp-options.pac b/src/analyzer/protocol/dhcp/dhcp-options.pac index a53398eabc..96dfd8bacf 100644 --- a/src/analyzer/protocol/dhcp/dhcp-options.pac +++ b/src/analyzer/protocol/dhcp/dhcp-options.pac @@ -750,11 +750,11 @@ refine flow DHCP_Flow += { for ( auto ptrsubopt = ${v.relay_agent_inf}->begin(); ptrsubopt != ${v.relay_agent_inf}->end(); ++ptrsubopt ) { - auto r = new RecordVal(zeek::BifType::Record::DHCP::SubOpt); + auto r = make_intrusive(zeek::BifType::Record::DHCP::SubOpt); r->Assign(0, val_mgr->Count((*ptrsubopt)->code())); r->Assign(1, to_stringval((*ptrsubopt)->value())); - relay_agent_sub_opt->Assign(i, r); + relay_agent_sub_opt->Assign(i, std::move(r)); ++i; } diff --git a/src/analyzer/protocol/krb/krb-padata.pac b/src/analyzer/protocol/krb/krb-padata.pac index 5617e48fb6..957df4e789 100644 --- a/src/analyzer/protocol/krb/krb-padata.pac +++ b/src/analyzer/protocol/krb/krb-padata.pac @@ -36,26 +36,26 @@ IntrusivePtr proc_padata(const KRB_PA_Data_Sequence* data, const BroA break; case PA_PW_SALT: { - RecordVal * type_val = new RecordVal(zeek::BifType::Record::KRB::Type_Value); + auto type_val = make_intrusive(zeek::BifType::Record::KRB::Type_Value); type_val->Assign(0, val_mgr->Count(element->data_type())); type_val->Assign(1, to_stringval(element->pa_data_element()->pa_pw_salt()->encoding()->content())); - vv->Assign(vv->Size(), type_val); + vv->Assign(vv->Size(), std::move(type_val)); break; } case PA_ENCTYPE_INFO: { - RecordVal * type_val = new RecordVal(zeek::BifType::Record::KRB::Type_Value); + auto type_val = make_intrusive(zeek::BifType::Record::KRB::Type_Value); type_val->Assign(0, val_mgr->Count(element->data_type())); type_val->Assign(1, to_stringval(element->pa_data_element()->pf_enctype_info()->salt())); - vv->Assign(vv->Size(), type_val); + vv->Assign(vv->Size(), std::move(type_val)); break; } case PA_ENCTYPE_INFO2: { - RecordVal * type_val = new RecordVal(zeek::BifType::Record::KRB::Type_Value); + auto type_val = make_intrusive(zeek::BifType::Record::KRB::Type_Value); type_val->Assign(0, val_mgr->Count(element->data_type())); type_val->Assign(1, to_stringval(element->pa_data_element()->pf_enctype_info2()->salt())); - vv->Assign(vv->Size(), type_val); + vv->Assign(vv->Size(), std::move(type_val)); break; } case PA_PW_AS_REQ: @@ -110,10 +110,10 @@ IntrusivePtr proc_padata(const KRB_PA_Data_Sequence* data, const BroA { if ( ! is_error && element->pa_data_element()->unknown()->meta()->length() > 0 ) { - RecordVal * type_val = new RecordVal(zeek::BifType::Record::KRB::Type_Value); + auto type_val = make_intrusive(zeek::BifType::Record::KRB::Type_Value); type_val->Assign(0, val_mgr->Count(element->data_type())); type_val->Assign(1, to_stringval(element->pa_data_element()->unknown()->content())); - vv->Assign(vv->Size(), type_val); + vv->Assign(vv->Size(), std::move(type_val)); } break; } diff --git a/src/analyzer/protocol/rpc/NFS.cc b/src/analyzer/protocol/rpc/NFS.cc index 1ca6bbd89d..68a054dc6d 100644 --- a/src/analyzer/protocol/rpc/NFS.cc +++ b/src/analyzer/protocol/rpc/NFS.cc @@ -765,7 +765,7 @@ IntrusivePtr NFS_Interp::nfs3_readdir_reply(bool isplus, const u_char while ( extract_XDR_uint32(buf,n) ) { - RecordVal *entry = new RecordVal(zeek::BifType::Record::NFS3::direntry_t); + auto entry = make_intrusive(zeek::BifType::Record::NFS3::direntry_t); entry->Assign(0, ExtractUint64(buf,n)); // fileid entry->Assign(1, nfs3_filename(buf,n)); // fname entry->Assign(2, ExtractUint64(buf,n)); // cookie @@ -776,7 +776,7 @@ IntrusivePtr NFS_Interp::nfs3_readdir_reply(bool isplus, const u_char entry->Assign(4, nfs3_post_op_fh(buf,n)); } - entries->Assign(pos, entry); + entries->Assign(pos, std::move(entry)); pos++; } diff --git a/src/analyzer/protocol/ssl/tls-handshake-analyzer.pac b/src/analyzer/protocol/ssl/tls-handshake-analyzer.pac index ca7801c395..7db8d7584f 100644 --- a/src/analyzer/protocol/ssl/tls-handshake-analyzer.pac +++ b/src/analyzer/protocol/ssl/tls-handshake-analyzer.pac @@ -161,10 +161,10 @@ refine connection Handshake_Conn += { { for ( unsigned int i = 0; i < supported_signature_algorithms->size(); ++i ) { - RecordVal* el = new RecordVal(zeek::BifType::Record::SSL::SignatureAndHashAlgorithm); + auto el = make_intrusive(zeek::BifType::Record::SSL::SignatureAndHashAlgorithm); el->Assign(0, val_mgr->Count((*supported_signature_algorithms)[i]->HashAlgorithm())); el->Assign(1, val_mgr->Count((*supported_signature_algorithms)[i]->SignatureAlgorithm())); - slist->Assign(i, el); + slist->Assign(i, std::move(el)); } } @@ -498,10 +498,10 @@ refine connection Handshake_Conn += { { for ( auto&& identity : *(identities->identities()) ) { - RecordVal* el = new RecordVal(zeek::BifType::Record::SSL::PSKIdentity); + auto el = make_intrusive(zeek::BifType::Record::SSL::PSKIdentity); el->Assign(0, make_intrusive(identity->identity().length(), (const char*) identity->identity().data())); el->Assign(1, val_mgr->Count(identity->obfuscated_ticket_age())); - slist->Assign(slist->Size(), el); + slist->Assign(slist->Size(), std::move(el)); } } diff --git a/src/analyzer/protocol/tcp/TCP.cc b/src/analyzer/protocol/tcp/TCP.cc index 27d8235483..d61c246c8f 100644 --- a/src/analyzer/protocol/tcp/TCP.cc +++ b/src/analyzer/protocol/tcp/TCP.cc @@ -1358,7 +1358,7 @@ int TCP_Analyzer::ParseTCPOptions(const struct tcphdr* tcp, bool is_orig) { auto option_list = make_intrusive(zeek::BifType::Vector::TCP::OptionList); - auto add_option_data = [](RecordVal* rv, const u_char* odata, int olen) + auto add_option_data = [](const IntrusivePtr& rv, const u_char* odata, int olen) { if ( olen <= 2 ) return; @@ -1372,7 +1372,7 @@ int TCP_Analyzer::ParseTCPOptions(const struct tcphdr* tcp, bool is_orig) { auto kind = o[0]; auto length = kind < 2 ? 1 : o[1]; - auto option_record = new RecordVal(zeek::BifType::Record::TCP::Option); + auto option_record = make_intrusive(zeek::BifType::Record::TCP::Option); option_list->Assign(option_list->Size(), option_record); option_record->Assign(0, val_mgr->Count(kind)); option_record->Assign(1, val_mgr->Count(length)); diff --git a/src/broker/comm.bif b/src/broker/comm.bif index c49e90801e..6b63029f17 100644 --- a/src/broker/comm.bif +++ b/src/broker/comm.bif @@ -102,7 +102,7 @@ function Broker::__peers%(%): PeerInfos const auto& pi = zeek::id::find_type("Broker::PeerInfo"); const auto& ei = zeek::id::find_type("Broker::EndpointInfo"); const auto& ni = zeek::id::find_type("Broker::NetworkInfo"); - auto peer_info = new RecordVal(pi); + auto peer_info = make_intrusive(pi); auto endpoint_info = make_intrusive(ei); auto network_info = make_intrusive(ni); auto n = p.peer.network; @@ -125,7 +125,7 @@ function Broker::__peers%(%): PeerInfos peer_info->Assign(0, std::move(endpoint_info)); peer_info->Assign(1, zeek::BifType::Enum::Broker::PeerStatus->GetVal(ps)); - rval->Assign(i, peer_info); + rval->Assign(i, std::move(peer_info)); ++i; } diff --git a/src/file_analysis/analyzer/x509/X509.cc b/src/file_analysis/analyzer/x509/X509.cc index 6588153646..b3bd999dd9 100644 --- a/src/file_analysis/analyzer/x509/X509.cc +++ b/src/file_analysis/analyzer/x509/X509.cc @@ -362,7 +362,7 @@ void file_analysis::X509::ParseSAN(X509_EXTENSION* ext) #else const char* name = (const char*) ASN1_STRING_get0_data(gen->d.ia5); #endif - StringVal* bs = new StringVal(name); + auto bs = make_intrusive(name); switch ( gen->type ) { @@ -370,21 +370,21 @@ void file_analysis::X509::ParseSAN(X509_EXTENSION* ext) if ( names == nullptr ) names = make_intrusive(zeek::id::string_vec); - names->Assign(names->Size(), bs); + names->Assign(names->Size(), std::move(bs)); break; case GEN_URI: if ( uris == nullptr ) uris = make_intrusive(zeek::id::string_vec); - uris->Assign(uris->Size(), bs); + uris->Assign(uris->Size(), std::move(bs)); break; case GEN_EMAIL: if ( emails == nullptr ) emails = make_intrusive(zeek::id::string_vec); - emails->Assign(emails->Size(), bs); + emails->Assign(emails->Size(), std::move(bs)); break; } } diff --git a/src/input/Manager.cc b/src/input/Manager.cc index 532f9f9e03..2871b42ba8 100644 --- a/src/input/Manager.cc +++ b/src/input/Manager.cc @@ -2275,7 +2275,10 @@ Val* Manager::ValueToVal(const Stream* i, const Value* val, BroType* request_typ auto v = make_intrusive(std::move(vt)); for ( int j = 0; j < val->val.vector_val.size; j++ ) - v->Assign(j, ValueToVal(i, val->val.vector_val.vals[j], type.get(), have_error)); + { + auto el = ValueToVal(i, val->val.vector_val.vals[j], type.get(), have_error); + v->Assign(j, {AdoptRef{}, el}); + } return v.release(); } diff --git a/src/probabilistic/Topk.cc b/src/probabilistic/Topk.cc index 38bf2d625f..a6942ddbca 100644 --- a/src/probabilistic/Topk.cc +++ b/src/probabilistic/Topk.cc @@ -209,7 +209,7 @@ IntrusivePtr TopkVal::GetTopK(int k) const // returns vector while ( eit != (*it)->elements.end() ) { //printf("Size: %ld\n", (*it)->elements.size()); - t->Assign(read, (*eit)->value->Ref()); + t->Assign(read, (*eit)->value); read++; eit++; } diff --git a/src/threading/SerialTypes.cc b/src/threading/SerialTypes.cc index 1e48e78c17..1f6e6acd34 100644 --- a/src/threading/SerialTypes.cc +++ b/src/threading/SerialTypes.cc @@ -588,7 +588,10 @@ Val* Value::ValueToVal(const std::string& source, const Value* val, bool& have_e auto v = make_intrusive(std::move(vt)); for ( int j = 0; j < val->val.vector_val.size; j++ ) - v->Assign(j, ValueToVal(source, val->val.vector_val.vals[j], have_error)); + { + auto el = ValueToVal(source, val->val.vector_val.vals[j], have_error); + v->Assign(j, {AdoptRef{}, el}); + } return v.release(); }