shared poitners to it instead of real objects.
no functional change yet, so the conversion is basically only about the
syntax.
// Find A rrset
if (qname_ != qname || qtype_ != RRType::A()) {
- ZoneFinder::FindResult a_result = zone.find(qname, RRType::A(),
- options | dnssec_opt_);
- if (a_result.code == ZoneFinder::SUCCESS) {
+ ZoneFinderContextPtr a_ctx = zone.find(qname, RRType::A(),
+ options | dnssec_opt_);
+ if (a_ctx->code == ZoneFinder::SUCCESS) {
response_.addRRset(Message::SECTION_ADDITIONAL,
- boost::const_pointer_cast<AbstractRRset>(a_result.rrset), dnssec_);
+ boost::const_pointer_cast<AbstractRRset>(a_ctx->rrset), dnssec_);
}
}
// Find AAAA rrset
if (qname_ != qname || qtype_ != RRType::AAAA()) {
- ZoneFinder::FindResult aaaa_result = zone.find(qname, RRType::AAAA(),
- options | dnssec_opt_);
- if (aaaa_result.code == ZoneFinder::SUCCESS) {
+ ZoneFinderContextPtr aaaa_ctx = zone.find(qname, RRType::AAAA(),
+ options | dnssec_opt_);
+ if (aaaa_ctx->code == ZoneFinder::SUCCESS) {
response_.addRRset(Message::SECTION_ADDITIONAL,
- boost::const_pointer_cast<AbstractRRset>(aaaa_result.rrset),
+ boost::const_pointer_cast<AbstractRRset>(aaaa_ctx->rrset),
dnssec_);
}
}
void
Query::addSOA(ZoneFinder& finder) {
- ZoneFinder::FindResult soa_result = finder.find(finder.getOrigin(),
- RRType::SOA(),
- dnssec_opt_);
- if (soa_result.code != ZoneFinder::SUCCESS) {
+ ZoneFinderContextPtr soa_ctx = finder.find(finder.getOrigin(),
+ RRType::SOA(), dnssec_opt_);
+ if (soa_ctx->code != ZoneFinder::SUCCESS) {
isc_throw(NoSOA, "There's no SOA record in zone " <<
finder.getOrigin().toText());
} else {
* to insist.
*/
response_.addRRset(Message::SECTION_AUTHORITY,
- boost::const_pointer_cast<AbstractRRset>(soa_result.rrset), dnssec_);
+ boost::const_pointer_cast<AbstractRRset>(soa_ctx->rrset), dnssec_);
}
}
// Confirm the wildcard doesn't exist (this should result in NXDOMAIN;
// otherwise we shouldn't have got NXDOMAIN for the original query in
// the first place).
- const ZoneFinder::FindResult fresult =
+ ConstZoneFinderContextPtr fcontext =
finder.find(wildname, RRType::NSEC(), dnssec_opt_);
- if (fresult.code != ZoneFinder::NXDOMAIN || !fresult.rrset ||
- fresult.rrset->getRdataCount() == 0) {
+ if (fcontext->code != ZoneFinder::NXDOMAIN || !fcontext->rrset ||
+ fcontext->rrset->getRdataCount() == 0) {
isc_throw(BadNSEC, "Unexpected result for wildcard NXDOMAIN proof");
}
// Note: name comparison is relatively expensive. When we are at the
// stage of performance optimization, we should consider optimizing this
// for some optimized data source implementations.
- if (nsec->getName() != fresult.rrset->getName()) {
+ if (nsec->getName() != fcontext->rrset->getName()) {
response_.addRRset(Message::SECTION_AUTHORITY,
- boost::const_pointer_cast<AbstractRRset>(fresult.rrset),
+ boost::const_pointer_cast<AbstractRRset>(fcontext->rrset),
dnssec_);
}
}
void
Query::addWildcardProof(ZoneFinder& finder,
- const ZoneFinder::FindResult& db_result)
+ const ZoneFinder::Context& db_context)
{
- if (db_result.isNSECSigned()) {
+ if (db_context.isNSECSigned()) {
// Case for RFC4035 Section 3.1.3.3.
//
// The query name shouldn't exist in the zone if there were no wildcard
// substitution. Confirm that by specifying NO_WILDCARD. It should
// result in NXDOMAIN and an NSEC RR that proves it should be returned.
- const ZoneFinder::FindResult fresult =
+ ConstZoneFinderContextPtr fcontext =
finder.find(qname_, RRType::NSEC(),
dnssec_opt_ | ZoneFinder::NO_WILDCARD);
- if (fresult.code != ZoneFinder::NXDOMAIN || !fresult.rrset ||
- fresult.rrset->getRdataCount() == 0) {
+ if (fcontext->code != ZoneFinder::NXDOMAIN || !fcontext->rrset ||
+ fcontext->rrset->getRdataCount() == 0) {
isc_throw(BadNSEC,
"Unexpected NSEC result for wildcard proof");
}
response_.addRRset(Message::SECTION_AUTHORITY,
boost::const_pointer_cast<AbstractRRset>(
- fresult.rrset),
+ fcontext->rrset),
dnssec_);
- } else if (db_result.isNSEC3Signed()) {
+ } else if (db_context.isNSEC3Signed()) {
// Case for RFC 5155 Section 7.2.6.
//
// Note that the closest encloser must be the immediate ancestor
isc_throw(BadNSEC, "NSEC for WILDCARD_NXRRSET is empty");
}
- const ZoneFinder::FindResult fresult =
+ ConstZoneFinderContextPtr fcontext =
finder.find(qname_, RRType::NSEC(),
dnssec_opt_ | ZoneFinder::NO_WILDCARD);
- if (fresult.code != ZoneFinder::NXDOMAIN || !fresult.rrset ||
- fresult.rrset->getRdataCount() == 0) {
+ if (fcontext->code != ZoneFinder::NXDOMAIN || !fcontext->rrset ||
+ fcontext->rrset->getRdataCount() == 0) {
isc_throw(BadNSEC, "Unexpected result for no match QNAME proof");
}
- if (nsec->getName() != fresult.rrset->getName()) {
+ if (nsec->getName() != fcontext->rrset->getName()) {
// one NSEC RR proves wildcard_nxrrset that no matched QNAME.
response_.addRRset(Message::SECTION_AUTHORITY,
- boost::const_pointer_cast<AbstractRRset>(fresult.rrset),
+ boost::const_pointer_cast<AbstractRRset>(fcontext->rrset),
dnssec_);
}
}
void
Query::addDS(ZoneFinder& finder, const Name& dname) {
- ZoneFinder::FindResult ds_result =
+ ConstZoneFinderContextPtr ds_context =
finder.find(dname, RRType::DS(), dnssec_opt_);
- if (ds_result.code == ZoneFinder::SUCCESS) {
+ if (ds_context->code == ZoneFinder::SUCCESS) {
response_.addRRset(Message::SECTION_AUTHORITY,
boost::const_pointer_cast<AbstractRRset>(
- ds_result.rrset),
+ ds_context->rrset),
dnssec_);
- } else if (ds_result.code == ZoneFinder::NXRRSET &&
- ds_result.isNSECSigned()) {
- addNXRRsetProof(finder, ds_result);
- } else if (ds_result.code == ZoneFinder::NXRRSET &&
- ds_result.isNSEC3Signed()) {
+ } else if (ds_context->code == ZoneFinder::NXRRSET &&
+ ds_context->isNSECSigned()) {
+ addNXRRsetProof(finder, *ds_context);
+ } else if (ds_context->code == ZoneFinder::NXRRSET &&
+ ds_context->isNSEC3Signed()) {
// Add no DS proof with NSEC3 as specified in RFC 5155 Section 7.2.7.
addClosestEncloserProof(finder, dname, true);
} else {
void
Query::addNXRRsetProof(ZoneFinder& finder,
- const ZoneFinder::FindResult& db_result)
+ const ZoneFinder::Context& db_context)
{
- if (db_result.isNSECSigned() && db_result.rrset) {
+ if (db_context.isNSECSigned() && db_context.rrset) {
response_.addRRset(Message::SECTION_AUTHORITY,
boost::const_pointer_cast<AbstractRRset>(
- db_result.rrset),
+ db_context.rrset),
dnssec_);
- if (db_result.isWildcard()) {
- addWildcardNXRRSETProof(finder, db_result.rrset);
+ if (db_context.isWildcard()) {
+ addWildcardNXRRSETProof(finder, db_context.rrset);
}
- } else if (db_result.isNSEC3Signed() && !db_result.isWildcard()) {
+ } else if (db_context.isNSEC3Signed() && !db_context.isWildcard()) {
if (qtype_ == RRType::DS()) {
// RFC 5155, Section 7.2.4. Add either NSEC3 for the qname or
// closest (provable) encloser proof in case of optout.
// RFC 5155, Section 7.2.3. Just add NSEC3 for the qname.
addNSEC3ForName(finder, qname_, true);
}
- } else if (db_result.isNSEC3Signed() && db_result.isWildcard()) {
+ } else if (db_context.isNSEC3Signed() && db_context.isWildcard()) {
// Case for RFC 5155 Section 7.2.5: add closest encloser proof for the
// qname, construct the matched wildcard name and add NSEC3 for it.
const uint8_t closest_labels =
void
Query::addAuthAdditional(ZoneFinder& finder) {
// Fill in authority and addtional sections.
- ZoneFinder::FindResult ns_result =
+ ConstZoneFinderContextPtr ns_context =
finder.find(finder.getOrigin(), RRType::NS(), dnssec_opt_);
// zone origin name should have NS records
- if (ns_result.code != ZoneFinder::SUCCESS) {
+ if (ns_context->code != ZoneFinder::SUCCESS) {
isc_throw(NoApexNS, "There's no apex NS records in zone " <<
finder.getOrigin().toText());
} else {
response_.addRRset(Message::SECTION_AUTHORITY,
- boost::const_pointer_cast<AbstractRRset>(ns_result.rrset), dnssec_);
+ boost::const_pointer_cast<AbstractRRset>(ns_context->rrset), dnssec_);
// Handle additional for authority section
- addAdditional(finder, *ns_result.rrset);
+ addAdditional(finder, *ns_context->rrset);
}
}
response_.setHeaderFlag(Message::HEADERFLAG_AA);
response_.setRcode(Rcode::NOERROR());
std::vector<ConstRRsetPtr> target;
- boost::function0<ZoneFinder::FindResult> find;
+ boost::function0<ZoneFinderContextPtr> find;
const bool qtype_is_any = (qtype_ == RRType::ANY());
if (qtype_is_any) {
find = boost::bind(&ZoneFinder::findAll, &zfinder, qname_,
find = boost::bind(&ZoneFinder::find, &zfinder, qname_, qtype_,
dnssec_opt_);
}
- ZoneFinder::FindResult db_result(find());
- switch (db_result.code) {
+ ZoneFinderContextPtr db_context(find());
+ switch (db_context->code) {
case ZoneFinder::DNAME: {
// First, put the dname into the answer
response_.addRRset(Message::SECTION_ANSWER,
- boost::const_pointer_cast<AbstractRRset>(db_result.rrset),
+ boost::const_pointer_cast<AbstractRRset>(db_context->rrset),
dnssec_);
/*
* Empty DNAME should never get in, as it is impossible to
*
* FIXME: Other way to prevent this should be done
*/
- assert(db_result.rrset->getRdataCount() > 0);
+ assert(db_context->rrset->getRdataCount() > 0);
// Get the data of DNAME
const rdata::generic::DNAME& dname(
dynamic_cast<const rdata::generic::DNAME&>(
- db_result.rrset->getRdataIterator()->getCurrent()));
+ db_context->rrset->getRdataIterator()->getCurrent()));
// The yet unmatched prefix dname
const Name prefix(qname_.split(0, qname_.getLabelCount() -
- db_result.rrset->getName().getLabelCount()));
+ db_context->rrset->getName().getLabelCount()));
// If we put it together, will it be too long?
// (The prefix contains trailing ., which will be removed
if (prefix.getLength() - Name::ROOT_NAME().getLength() +
// The new CNAME we are creating (it will be unsigned even
// with DNSSEC, the DNAME is signed and it can be validated
// by that)
- RRsetPtr cname(new RRset(qname_, db_result.rrset->getClass(),
- RRType::CNAME(), db_result.rrset->getTTL()));
+ RRsetPtr cname(new RRset(qname_, db_context->rrset->getClass(),
+ RRType::CNAME(), db_context->rrset->getTTL()));
// Construct the new target by replacing the end
cname->addRdata(rdata::generic::CNAME(qname_.split(0,
qname_.getLabelCount() -
- db_result.rrset->getName().getLabelCount()).
+ db_context->rrset->getName().getLabelCount()).
concatenate(dname.getDname())));
response_.addRRset(Message::SECTION_ANSWER, cname, dnssec_);
break;
* So, just put it there.
*/
response_.addRRset(Message::SECTION_ANSWER,
- boost::const_pointer_cast<AbstractRRset>(db_result.rrset),
+ boost::const_pointer_cast<AbstractRRset>(db_context->rrset),
dnssec_);
// If the answer is a result of wildcard substitution,
// add a proof that there's no closer name.
- if (dnssec_ && db_result.isWildcard()) {
- addWildcardProof(*result.zone_finder,db_result);
+ if (dnssec_ && db_context->isWildcard()) {
+ addWildcardProof(*result.zone_finder, *db_context);
}
break;
case ZoneFinder::SUCCESS:
}
} else {
response_.addRRset(Message::SECTION_ANSWER,
- boost::const_pointer_cast<AbstractRRset>(db_result.rrset),
+ boost::const_pointer_cast<AbstractRRset>(db_context->rrset),
dnssec_);
// Handle additional for answer section
- addAdditional(*result.zone_finder, *db_result.rrset);
+ addAdditional(*result.zone_finder, *db_context->rrset);
}
// If apex NS records haven't been provided in the answer
// section, insert apex NS records into the authority section
// and AAAA/A RRS of each of the NS RDATA into the additional
// section.
if (qname_ != result.zone_finder->getOrigin() ||
- db_result.code != ZoneFinder::SUCCESS ||
+ db_context->code != ZoneFinder::SUCCESS ||
(qtype_ != RRType::NS() && !qtype_is_any))
{
addAuthAdditional(*result.zone_finder);
// If the answer is a result of wildcard substitution,
// add a proof that there's no closer name.
- if (dnssec_ && db_result.isWildcard()) {
- addWildcardProof(*result.zone_finder,db_result);
+ if (dnssec_ && db_context->isWildcard()) {
+ addWildcardProof(*result.zone_finder, *db_context);
}
break;
case ZoneFinder::DELEGATION:
response_.setHeaderFlag(Message::HEADERFLAG_AA, false);
response_.addRRset(Message::SECTION_AUTHORITY,
- boost::const_pointer_cast<AbstractRRset>(db_result.rrset),
+ boost::const_pointer_cast<AbstractRRset>(db_context->rrset),
dnssec_);
// If DNSSEC is requested, see whether there is a DS
// record for this delegation.
if (dnssec_) {
- addDS(*result.zone_finder, db_result.rrset->getName());
+ addDS(*result.zone_finder, db_context->rrset->getName());
}
- addAdditional(*result.zone_finder, *db_result.rrset);
+ addAdditional(*result.zone_finder, *db_context->rrset);
break;
case ZoneFinder::NXDOMAIN:
response_.setRcode(Rcode::NXDOMAIN());
addSOA(*result.zone_finder);
if (dnssec_) {
- if (db_result.isNSECSigned() && db_result.rrset) {
- addNXDOMAINProofByNSEC(zfinder, db_result.rrset);
- } else if (db_result.isNSEC3Signed()) {
+ if (db_context->isNSECSigned() && db_context->rrset) {
+ addNXDOMAINProofByNSEC(zfinder, db_context->rrset);
+ } else if (db_context->isNSEC3Signed()) {
addNXDOMAINProofByNSEC3(zfinder);
}
}
case ZoneFinder::NXRRSET:
addSOA(*result.zone_finder);
if (dnssec_) {
- addNXRRsetProof(zfinder, db_result);
+ addNXRRsetProof(zfinder, *db_context);
}
break;
default:
response_.setHeaderFlag(Message::HEADERFLAG_AA);
response_.setRcode(Rcode::NOERROR());
addSOA(*zresult.zone_finder);
- const ZoneFinder::FindResult ds_result =
+ ConstZoneFinderContextPtr ds_context =
zresult.zone_finder->find(qname_, RRType::DS(), dnssec_opt_);
- if (ds_result.code == ZoneFinder::NXRRSET) {
+ if (ds_context->code == ZoneFinder::NXRRSET) {
if (dnssec_) {
- addNXRRsetProof(*zresult.zone_finder, ds_result);
+ addNXRRsetProof(*zresult.zone_finder, *ds_context);
}
}
/// data
/// \param db_result The ZoneFinder::FindResult returned by find()
void addNXRRsetProof(isc::datasrc::ZoneFinder& finder,
- const isc::datasrc::ZoneFinder::FindResult& db_result);
+ const isc::datasrc::ZoneFinder::Context& db_context);
/// Add NSEC RRs that prove an NXDOMAIN result.
///
/// of RFC5155.
void addWildcardProof(
isc::datasrc::ZoneFinder& finder,
- const isc::datasrc::ZoneFinder::FindResult& dbResult);
+ const isc::datasrc::ZoneFinder::Context& db_context);
/// \brief Adds one NSEC RR proved no matched QNAME,one NSEC RR proved no
/// matched <QNAME,QTYPE> through wildcard extension.
EXPECT_TRUE(server.getInMemoryClient(RRClass::IN()));
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test1.example")).zone_finder->
- find(Name("ns.test1.example"), RRType::A()).code);
+ find(Name("ns.test1.example"), RRType::A())->code);
EXPECT_EQ(ZoneFinder::NXRRSET, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test1.example")).zone_finder->
- find(Name("ns.test1.example"), RRType::AAAA()).code);
+ find(Name("ns.test1.example"), RRType::AAAA())->code);
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test2.example")).zone_finder->
- find(Name("ns.test2.example"), RRType::A()).code);
+ find(Name("ns.test2.example"), RRType::A())->code);
EXPECT_EQ(ZoneFinder::NXRRSET, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test2.example")).zone_finder->
- find(Name("ns.test2.example"), RRType::AAAA()).code);
+ find(Name("ns.test2.example"), RRType::AAAA())->code);
}
void
EXPECT_TRUE(server.getInMemoryClient(RRClass::IN()));
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test1.example")).zone_finder->
- find(Name("ns.test1.example"), RRType::A()).code);
+ find(Name("ns.test1.example"), RRType::A())->code);
// now test1.example should have ns/AAAA
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test1.example")).zone_finder->
- find(Name("ns.test1.example"), RRType::AAAA()).code);
+ find(Name("ns.test1.example"), RRType::AAAA())->code);
// test2.example shouldn't change
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test2.example")).zone_finder->
- find(Name("ns.test2.example"), RRType::A()).code);
+ find(Name("ns.test2.example"), RRType::A())->code);
EXPECT_EQ(ZoneFinder::NXRRSET, server.getInMemoryClient(RRClass::IN())->
findZone(Name("ns.test2.example")).zone_finder->
- find(Name("ns.test2.example"), RRType::AAAA()).code);
+ find(Name("ns.test2.example"), RRType::AAAA())->code);
}
TEST_F(AuthCommandTest, loadZone) {
// Check it actually loaded something
EXPECT_EQ(ZoneFinder::SUCCESS, server.getInMemoryClient(rrclass)->findZone(
Name("ns.example.com.")).zone_finder->find(Name("ns.example.com."),
- RRType::A()).code);
+ RRType::A())->code);
}
TEST_F(MemoryDatasrcConfigTest, addMultiZones) {
}
virtual isc::dns::Name getOrigin() const { return (origin_); }
virtual isc::dns::RRClass getClass() const { return (rrclass_); }
- virtual FindResult find(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- const FindOptions options = FIND_DEFAULT);
- virtual FindResult findAll(const isc::dns::Name& name,
- std::vector<ConstRRsetPtr>& target,
- const FindOptions options = FIND_DEFAULT);
+ virtual ZoneFinderContextPtr find(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ const FindOptions options =
+ FIND_DEFAULT);
+ virtual ZoneFinderContextPtr findAll(const isc::dns::Name& name,
+ std::vector<ConstRRsetPtr>& target,
+ const FindOptions options =
+ FIND_DEFAULT);
virtual ZoneFinder::FindNSEC3Result
findNSEC3(const Name& name, bool recursive);
ConstRRsetPtr rrset)
{
nsec_name_ = nsec_name;
- nsec_result_.reset(new ZoneFinder::FindResult(code, rrset,
- RESULT_NSEC_SIGNED));
+ nsec_context_.reset(new Context(code, rrset, RESULT_NSEC_SIGNED));
}
// Once called, the findNSEC3 will return the provided result for the next
bool use_nsec3_;
// The following two will be used for faked NSEC cases
Name nsec_name_;
- boost::scoped_ptr<ZoneFinder::FindResult> nsec_result_;
+ ZoneFinderContextPtr nsec_context_;
// The following two are for faking bad NSEC3 responses
// Enabled when not NULL
const FindNSEC3Result* nsec3_fake_;
return (rrset);
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
MockZoneFinder::findAll(const Name& name, std::vector<ConstRRsetPtr>& target,
const FindOptions options)
{
- ZoneFinder::FindResult result(find(name, RRType::ANY(), options));
- if (result.code == NXRRSET) {
+ ZoneFinderContextPtr result(find(name, RRType::ANY(), options));
+ if (result->code == NXRRSET) {
const Domains::const_iterator found_domain = domains_.find(name);
if (!found_domain->second.empty()) {
for (RRsetStore::const_iterator found_rrset =
// Insert RRs under the domain name into target
target.push_back(found_rrset->second);
}
- return (FindResult(SUCCESS, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(SUCCESS, RRsetPtr())));
}
}
isc_throw(isc::Unexpected, "findNSEC3() isn't expected to fail");
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
MockZoneFinder::find(const Name& name, const RRType& type,
const FindOptions options)
{
// Emulating a broken zone: mandatory apex RRs are missing if specifically
// configured so (which are rare cases).
if (name == origin_ && type == RRType::SOA() && !has_SOA_) {
- return (FindResult(NXDOMAIN, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, RRsetPtr())));
} else if (name == origin_ && type == RRType::NS() && !has_apex_NS_) {
- return (FindResult(NXDOMAIN, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, RRsetPtr())));
}
// Special case for names on or under a zone cut and under DNAME
// handled just like an in-zone case below. Others result in
// DELEGATION.
if (type != RRType::DS() || it->first != name) {
- return (FindResult(DELEGATION, delegation_ns));
+ return (ZoneFinderContextPtr(new Context(DELEGATION,
+ delegation_ns)));
}
} else if (name.compare(dname_name_).getRelation() ==
NameComparisonResult::SUBDOMAIN) {
- return (FindResult(DNAME, dname_rrset_));
+ return (ZoneFinderContextPtr(new Context(DNAME, dname_rrset_)));
}
// normal cases. names are searched for only per exact-match basis
}
rrset = noconst;
}
- return (FindResult(SUCCESS, rrset));
+ return (ZoneFinderContextPtr(new Context(SUCCESS, rrset)));
}
// Otherwise, if this domain name has CNAME, return it.
found_rrset = found_domain->second.find(RRType::CNAME());
if (found_rrset != found_domain->second.end()) {
- return (FindResult(CNAME, found_rrset->second));
+ return (ZoneFinderContextPtr(new Context(CNAME,
+ found_rrset->second)));
}
// Otherwise it's NXRRSET case...
// ...but a special pathological case first:
if (found_domain->first == bad_signed_delegation_name_ &&
type == RRType::DS()) {
- return (FindResult(NXDOMAIN, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, RRsetPtr())));
}
// normal cases follow.
if ((options & FIND_DNSSEC) != 0) {
if (use_nsec3_) {
- return (FindResult(NXRRSET, RRsetPtr(), RESULT_NSEC3_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, RRsetPtr(),
+ RESULT_NSEC3_SIGNED)));
}
found_rrset = found_domain->second.find(RRType::NSEC());
if (found_rrset != found_domain->second.end()) {
- return (FindResult(NXRRSET, found_rrset->second,
- RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXRRSET,
+ found_rrset->second,
+ RESULT_NSEC_SIGNED)));
}
}
- return (FindResult(NXRRSET, RRsetPtr(), RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, RRsetPtr(),
+ RESULT_NSEC_SIGNED)));
}
// query name isn't found in our domains.
--domain; // reset domain to the "previous name"
if ((options & FIND_DNSSEC) != 0) {
if (use_nsec3_) {
- return (FindResult(NXRRSET, RRsetPtr(), RESULT_NSEC3_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, RRsetPtr(),
+ RESULT_NSEC3_SIGNED)));
}
RRsetStore::const_iterator found_rrset =
(*domain).second.find(RRType::NSEC());
if (found_rrset != (*domain).second.end()) {
- return (FindResult(NXRRSET, found_rrset->second,
- RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(
+ new Context(NXRRSET, found_rrset->second,
+ RESULT_NSEC_SIGNED)));
}
}
- return (FindResult(NXRRSET, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, RRsetPtr())));
}
// Another possibility is wildcard. For simplicity we only check
domain->second.find(type);
// Matched the QTYPE
if(found_rrset != domain->second.end()) {
- return (FindResult(SUCCESS,
- substituteWild(
- *found_rrset->second, name),
- RESULT_WILDCARD |
- (use_nsec3_ ?
- RESULT_NSEC3_SIGNED :
- RESULT_NSEC_SIGNED)));
+ return (ZoneFinderContextPtr(
+ new Context(SUCCESS,
+ substituteWild(
+ *found_rrset->second,
+ name),
+ RESULT_WILDCARD |
+ (use_nsec3_ ?
+ RESULT_NSEC3_SIGNED :
+ RESULT_NSEC_SIGNED))));
} else {
// No matched QTYPE, this case is for NXRRSET with
// WILDCARD
if (use_nsec3_) {
- return (FindResult(NXRRSET, RRsetPtr(),
- RESULT_WILDCARD |
- RESULT_NSEC3_SIGNED));
+ return (ZoneFinderContextPtr(
+ new Context(NXRRSET, RRsetPtr(),
+ RESULT_WILDCARD |
+ RESULT_NSEC3_SIGNED)));
}
const Name new_name =
Name("*").concatenate(wild_suffix);
found_rrset = domain->second.find(RRType::NSEC());
assert(found_rrset != domain->second.end());
- return (FindResult(NXRRSET,
- substituteWild(
- *found_rrset->second,
- new_name),
- RESULT_WILDCARD |
- RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(
+ new Context(NXRRSET,
+ substituteWild(
+ *found_rrset->second,
+ new_name),
+ RESULT_WILDCARD |
+ RESULT_NSEC_SIGNED)));
}
} else {
// This is empty non terminal name case on wildcard.
const Name empty_name = Name("*").concatenate(wild_suffix);
if (use_nsec3_) {
- return (FindResult(NXRRSET, RRsetPtr(),
- RESULT_WILDCARD |
- RESULT_NSEC3_SIGNED));
+ return (ZoneFinderContextPtr(
+ new Context(NXRRSET, RRsetPtr(),
+ RESULT_WILDCARD |
+ RESULT_NSEC3_SIGNED)));
}
for (Domains::reverse_iterator it = domains_.rbegin();
it != domains_.rend();
if ((*it).first < empty_name &&
(nsec_it = (*it).second.find(RRType::NSEC()))
!= (*it).second.end()) {
- return (FindResult(NXRRSET, (*nsec_it).second,
- RESULT_WILDCARD |
- RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(
+ new Context(NXRRSET, (*nsec_it).second,
+ RESULT_WILDCARD |
+ RESULT_NSEC_SIGNED)));
}
}
}
- return (FindResult(NXRRSET, RRsetPtr(), RESULT_WILDCARD));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, RRsetPtr(),
+ RESULT_WILDCARD)));
}
}
const Name cnamewild_suffix("cnamewild.example.com");
RRsetStore::const_iterator found_rrset =
domain->second.find(RRType::CNAME());
assert(found_rrset != domain->second.end());
- return (FindResult(CNAME,
- substituteWild(*found_rrset->second, name),
- RESULT_WILDCARD |
- (use_nsec3_ ? RESULT_NSEC3_SIGNED :
- RESULT_NSEC_SIGNED)));
+ return (ZoneFinderContextPtr(
+ new Context(CNAME,
+ substituteWild(*found_rrset->second, name),
+ RESULT_WILDCARD |
+ (use_nsec3_ ? RESULT_NSEC3_SIGNED :
+ RESULT_NSEC_SIGNED))));
}
}
// than the origin)
if ((options & FIND_DNSSEC) != 0) {
if (use_nsec3_) {
- return (FindResult(NXDOMAIN, RRsetPtr(), RESULT_NSEC3_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, RRsetPtr(),
+ RESULT_NSEC3_SIGNED)));
}
// Emulate a broken DataSourceClient for some special names.
- if (nsec_result_ && nsec_name_ == name) {
- return (*nsec_result_);
+ if (nsec_context_ && nsec_name_ == name) {
+ return (nsec_context_);
}
// Normal case
if ((*it).first < name &&
(nsec_it = (*it).second.find(RRType::NSEC()))
!= (*it).second.end()) {
- return (FindResult(NXDOMAIN, (*nsec_it).second,
- RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN,
+ (*nsec_it).second,
+ RESULT_NSEC_SIGNED)));
}
}
}
- return (FindResult(NXDOMAIN, RRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, RRsetPtr())));
}
class QueryTest : public ::testing::Test {
MockZoneFinder(), origin_(origin), have_ds_(have_ds)
{}
virtual isc::dns::Name getOrigin() const { return (origin_); }
- virtual FindResult find(const isc::dns::Name&,
- const isc::dns::RRType& type,
- const FindOptions)
+ virtual ZoneFinderContextPtr find(const isc::dns::Name&,
+ const isc::dns::RRType& type,
+ const FindOptions)
{
if (type == RRType::SOA()) {
RRsetPtr soa = textToRRset(origin_.toText() + " 3600 IN SOA . . "
"0 0 0 0 0\n", origin_);
soa->addRRsig(RdataPtr(new generic::RRSIG(
getCommonRRSIGText("SOA"))));
- return (FindResult(SUCCESS, soa));
+ return (ZoneFinderContextPtr(new Context(SUCCESS, soa)));
}
if (type == RRType::NS()) {
RRsetPtr ns = textToRRset(origin_.toText() + " 3600 IN NS " +
Name("ns").concatenate(origin_).toText());
ns->addRRsig(RdataPtr(new generic::RRSIG(
getCommonRRSIGText("NS"))));
- return (FindResult(SUCCESS, ns));
+ return (ZoneFinderContextPtr(new Context(SUCCESS, ns)));
}
if (type == RRType::DS()) {
if (have_ds_) {
"3CD34AC1AFE51DE");
ds->addRRsig(RdataPtr(new generic::RRSIG(
getCommonRRSIGText("DS"))));
- return (FindResult(SUCCESS, ds));
+ return (ZoneFinderContextPtr(new Context(SUCCESS, ds)));
} else {
RRsetPtr nsec = textToRRset(origin_.toText() +
" 3600 IN NSEC " +
" SOA NSEC RRSIG");
nsec->addRRsig(RdataPtr(new generic::RRSIG(
getCommonRRSIGText("NSEC"))));
- return (FindResult(NXRRSET, nsec, RESULT_NSEC_SIGNED));
+ return (ZoneFinderContextPtr(new Context(NXRRSET, nsec,
+ RESULT_NSEC_SIGNED)));
}
}
// Returning NXDOMAIN is not correct, but doesn't matter for our tests.
- return (FindResult(NXDOMAIN, ConstRRsetPtr()));
+ return (ZoneFinderContextPtr(new Context(NXDOMAIN, ConstRRsetPtr())));
}
private:
const Name origin_;
// clean them up.
TEST_F(QueryTest, emptyNameWithNSEC3) {
mock_finder->setNSEC3Flag(true);
- ZoneFinder::FindResult result = mock_finder->find(
+ ZoneFinderContextPtr result = mock_finder->find(
Name("no.example.com"), RRType::A(), ZoneFinder::FIND_DNSSEC);
- EXPECT_EQ(ZoneFinder::NXRRSET, result.code);
- EXPECT_FALSE(result.rrset);
- EXPECT_TRUE(result.isNSEC3Signed());
- EXPECT_FALSE(result.isWildcard());
+ EXPECT_EQ(ZoneFinder::NXRRSET, result->code);
+ EXPECT_FALSE(result->rrset);
+ EXPECT_TRUE(result->isNSEC3Signed());
+ EXPECT_FALSE(result->isWildcard());
}
}
return (ConstRRsetPtr());
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
DatabaseClient::Finder::findAll(const isc::dns::Name& name,
std::vector<isc::dns::ConstRRsetPtr>& target,
const FindOptions options)
{
- return (findInternal(name, RRType::ANY(), &target, options));
+ return (ZoneFinderContextPtr(new Context(
+ findInternal(name, RRType::ANY(),
+ &target, options))));
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
DatabaseClient::Finder::find(const isc::dns::Name& name,
const isc::dns::RRType& type,
const FindOptions options)
if (type == RRType::ANY()) {
isc_throw(isc::Unexpected, "Use findAll to answer ANY");
}
- return (findInternal(name, type, NULL, options));
+ return (ZoneFinderContextPtr(new Context(
+ findInternal(name, type, NULL, options))));
}
DatabaseClient::Finder::DelegationSearchResult
// covering NSEC record.
//
// If none of the above applies in any level, the search fails with NXDOMAIN.
-ZoneFinder::FindResult
+ZoneFinder::Context
DatabaseClient::Finder::findWildcardMatch(
const isc::dns::Name& name, const isc::dns::RRType& type,
const FindOptions options, const DelegationSearchResult& dresult,
DATASRC_DATABASE_WILDCARD_CANCEL_NS).
arg(accessor_->getDBName()).arg(wildcard).
arg(dresult.first_ns->getName());
- return (FindResult(DELEGATION, dresult.first_ns));
-
+ return (Context(DELEGATION, dresult.first_ns));
} else if (!hasSubdomains(name.split(i - 1).toText())) {
// The wildcard match is the best one, find the final result
// at it. Note that wildcard should never be the zone origin.
DATASRC_DATABASE_WILDCARD_CANCEL_SUB).
arg(accessor_->getDBName()).arg(wildcard).
arg(name).arg(superdomain);
- return (FindResult(NXDOMAIN, ConstRRsetPtr()));
+ return (Context(NXDOMAIN, ConstRRsetPtr()));
}
} else if (hasSubdomains(wildcard)) {
if ((options & FIND_DNSSEC) != 0) {
ConstRRsetPtr nsec = findNSECCover(Name(wildcard));
if (nsec) {
- return (FindResult(NXRRSET, nsec,
- RESULT_WILDCARD | RESULT_NSEC_SIGNED));
+ return (Context(NXRRSET, nsec,
+ RESULT_WILDCARD | RESULT_NSEC_SIGNED));
}
}
- return (FindResult(NXRRSET, ConstRRsetPtr(), RESULT_WILDCARD));
+ return (Context(NXRRSET, ConstRRsetPtr(), RESULT_WILDCARD));
}
}
// Nothing found at any level.
- return (FindResult(NXDOMAIN, ConstRRsetPtr()));
+ return (Context(NXDOMAIN, ConstRRsetPtr()));
}
-ZoneFinder::FindResult
+ZoneFinder::Context
DatabaseClient::Finder::logAndCreateResult(
const Name& name, const string* wildname, const RRType& type,
ZoneFinder::Result code, ConstRRsetPtr rrset,
arg(getClass()).arg(*wildname);
}
}
- return (ZoneFinder::FindResult(code, rrset, flags));
+ return (Context(code, rrset, flags));
}
-ZoneFinder::FindResult
+ZoneFinder::Context
DatabaseClient::Finder::findOnNameResult(const Name& name,
const RRType& type,
const FindOptions options,
DATASRC_DATABASE_FOUND_NXRRSET, flags));
}
-ZoneFinder::FindResult
+ZoneFinder::Context
DatabaseClient::Finder::findNoNameResult(const Name& name, const RRType& type,
FindOptions options,
const DelegationSearchResult& dresult,
arg(accessor_->getDBName()).arg(name);
const ConstRRsetPtr nsec = dnssec_data ? findNSECCover(name) :
ConstRRsetPtr();
- return (FindResult(NXRRSET, nsec,
- nsec ? RESULT_NSEC_SIGNED : RESULT_DEFAULT));
+ return (Context(NXRRSET, nsec,
+ nsec ? RESULT_NSEC_SIGNED : RESULT_DEFAULT));
} else if ((options & NO_WILDCARD) == 0) {
// It's not an empty non-terminal and wildcard matching is not
// disabled, so check for wildcards. If there is a wildcard match
// (i.e. all results except NXDOMAIN) return it; otherwise fall
// through to the NXDOMAIN case below.
- const ZoneFinder::FindResult wresult =
+ const Context wcontext =
findWildcardMatch(name, type, options, dresult, target);
- if (wresult.code != NXDOMAIN) {
- return (wresult);
+ if (wcontext.code != NXDOMAIN) {
+ return (wcontext);
}
}
arg(accessor_->getDBName()).arg(name).arg(type).arg(getClass());
const ConstRRsetPtr nsec = dnssec_data ? findNSECCover(name) :
ConstRRsetPtr();
- return (FindResult(NXDOMAIN, nsec,
- nsec ? RESULT_NSEC_SIGNED : RESULT_DEFAULT));
+ return (Context(NXDOMAIN, nsec,
+ nsec ? RESULT_NSEC_SIGNED : RESULT_DEFAULT));
}
-ZoneFinder::FindResult
+ZoneFinder::Context
DatabaseClient::Finder::findInternal(const Name& name, const RRType& type,
std::vector<ConstRRsetPtr>* target,
const FindOptions options)
name.compare(getOrigin()).getRelation();
if (reln != NameComparisonResult::SUBDOMAIN &&
reln != NameComparisonResult::EQUAL) {
- return (FindResult(NXDOMAIN, ConstRRsetPtr()));
+ return (Context(NXDOMAIN, ConstRRsetPtr()));
}
// First, go through all superdomains from the origin down, searching for
const DelegationSearchResult dresult = findDelegationPoint(name, options);
if (dresult.rrset) {
// In this case no special flags are needed.
- return (FindResult(dresult.code, dresult.rrset));
+ return (Context(dresult.code, dresult.rrset));
}
// If there is no delegation, look for the exact match to the request
// Find the SOA of the zone (may or may not succeed). Note that
// this must be done before starting the iteration context.
soa_ = DatabaseClient::Finder(accessor_, zone.second, zone_name).
- find(zone_name, RRType::SOA()).rrset;
+ find(zone_name, RRType::SOA())->rrset;
// Request the context
context_ = accessor_->getAllRecords(zone.second);
#include <datasrc/data_source.h>
#include <datasrc/client.h>
-#include <datasrc/client.h>
+#include <datasrc/zone.h>
#include <datasrc/logger.h>
#include <dns/name.h>
/// \param type The RRType to find
/// \param options Options about how to search.
/// See ZoneFinder::FindOptions.
- virtual FindResult find(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- const FindOptions options = FIND_DEFAULT);
+ virtual ZoneFinderContextPtr find(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ const FindOptions options =
+ FIND_DEFAULT);
/// \brief Implementation of the ZoneFinder::findAll method.
///
/// In short, it is mostly the same thing as find, but it returns all
/// RRsets in the named node through the target parameter in successful
/// case. It acts the same in the unsuccessful one.
- virtual FindResult findAll(const isc::dns::Name& name,
- std::vector<isc::dns::ConstRRsetPtr>& target,
- const FindOptions options = FIND_DEFAULT);
+ virtual ZoneFinderContextPtr findAll(
+ const isc::dns::Name& name,
+ std::vector<isc::dns::ConstRRsetPtr>& target,
+ const FindOptions options = FIND_DEFAULT);
/// \brief Implementation of ZoneFinder::findPreviousName method.
virtual isc::dns::Name findPreviousName(const isc::dns::Name& query)
/// Parameters and behaviour is like of those combined together.
/// Unexpected parameters, like type != ANY and having the target, are
/// just that - unexpected and not checked.
- FindResult findInternal(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- std::vector<isc::dns::ConstRRsetPtr>* target,
- const FindOptions options = FIND_DEFAULT);
+ Context findInternal(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ std::vector<isc::dns::ConstRRsetPtr>* target,
+ const FindOptions options = FIND_DEFAULT);
+
/// \brief Searches database for RRsets of one domain.
///
/// This method scans RRs of single domain specified by name and
/// success due to an exact match). Also returned if there
/// is no match is an indication as to whether there was an
/// NXDOMAIN or an NXRRSET.
- FindResult findWildcardMatch(
+ Context findWildcardMatch(
const isc::dns::Name& name,
- const isc::dns::RRType& type, const FindOptions options,
+ const isc::dns::RRType& type,
+ const FindOptions options,
const DelegationSearchResult& dresult,
std::vector<isc::dns::ConstRRsetPtr>* target);
/// the above 4 cases). The return value is intended to be
/// usable as a return value of the caller of this helper
/// method.
- FindResult findOnNameResult(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- const FindOptions options,
- const bool is_origin,
- const FoundRRsets& found,
- const std::string* wildname,
- std::vector<isc::dns::ConstRRsetPtr>* target);
+ Context findOnNameResult(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ const FindOptions options,
+ const bool is_origin,
+ const FoundRRsets& found,
+ const std::string* wildname,
+ std::vector<isc::dns::ConstRRsetPtr>* target);
/// \brief Handle no match for name
///
/// indicating the match type (e.g. CNAME at the wildcard
/// match, no RRs of the requested type at the wildcard,
/// success due to an exact match).
- FindResult findNoNameResult(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- FindOptions options,
- const DelegationSearchResult& dresult,
- std::vector<isc::dns::ConstRRsetPtr>*
- target);
+ Context findNoNameResult(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ FindOptions options,
+ const DelegationSearchResult& dresult,
+ std::vector<isc::dns::ConstRRsetPtr>*
+ target);
/// Logs condition and creates result
///
///
/// \return FindResult object constructed from the code and rrset
/// arguments.
- FindResult logAndCreateResult(const isc::dns::Name& name,
- const std::string* wildname,
- const isc::dns::RRType& type,
- ZoneFinder::Result code,
- isc::dns::ConstRRsetPtr rrset,
- const isc::log::MessageID& log_id,
- FindResultFlags flags) const;
+ Context logAndCreateResult(const isc::dns::Name& name,
+ const std::string* wildname,
+ const isc::dns::RRType& type,
+ ZoneFinder::Result code,
+ isc::dns::ConstRRsetPtr rrset,
+ const isc::log::MessageID& log_id,
+ FindResultFlags flags) const;
/// \brief Checks if something lives below this domain.
///
}
#endif // __DATABASE_DATASRC_H
+
+// Local Variables:
+// mode: c++
+// End:
}
}
- // Set up FindResult object as a return value of find(), taking into
+ // Set up FindContext object as a return value of find(), taking into
// account wildcard matches and DNSSEC information. We set the NSEC/NSEC3
// flag when applicable regardless of the find option; the caller would
// simply ignore these when they didn't request DNSSEC related results.
- FindResult createFindResult(Result code, ConstRRsetPtr rrset,
- bool wild) const
+ ZoneFinderContextPtr createFindContext(Result code, ConstRRsetPtr rrset,
+ bool wild = false) const
{
FindResultFlags flags = RESULT_DEFAULT;
if (wild) {
zone_data_->nsec3_data_) {
flags = flags | RESULT_NSEC3_SIGNED;
}
- return (FindResult(code, rrset, flags));
+ return (ZoneFinderContextPtr(new Context(code, rrset, flags)));
}
// Implementation of InMemoryZoneFinder::find
- FindResult find(const Name& name, RRType type,
- std::vector<ConstRRsetPtr>* target,
- const FindOptions options) const
+ ZoneFinderContextPtr find(const Name& name, RRType type,
+ std::vector<ConstRRsetPtr>* target,
+ const FindOptions options) const
{
LOG_DEBUG(logger, DBG_TRACE_BASIC, DATASRC_MEM_FIND).arg(name).
arg(type);
arg(state.rrset_->getName());
// We were traversing a DNAME node (and wanted to go
// lower below it), so return the DNAME
- return (FindResult(DNAME, prepareRRset(name, state.rrset_,
+ return (createFindContext(DNAME,
+ prepareRRset(name, state.rrset_,
false, options)));
}
if (state.zonecut_node_ != NULL) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_DELEG_FOUND).
arg(state.rrset_->getName());
- return (FindResult(DELEGATION,
- prepareRRset(name, state.rrset_,
- false, options)));
+ return (createFindContext(DELEGATION,
+ prepareRRset(name, state.rrset_,
+ false, options)));
}
// If the RBTree search stopped at a node for a super domain
NameComparisonResult::SUPERDOMAIN) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_SUPER_STOP).
arg(name);
- return (createFindResult(NXRRSET, ConstRRsetPtr(), false));
+ return (createFindContext(NXRRSET, ConstRRsetPtr()));
}
/*
getLastComparisonResult().getCommonLabels() > 1) {
LOG_DEBUG(logger, DBG_TRACE_DATA,
DATASRC_MEM_WILDCARD_CANCEL).arg(name);
- return (createFindResult(NXDOMAIN, ConstRRsetPtr(),
- false));
+ return (createFindContext(NXDOMAIN, ConstRRsetPtr(),
+ false));
}
const Name wildcard(Name("*").concatenate(
node_path.getAbsoluteName()));
case DomainTree::NOTFOUND:
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_NOT_FOUND).
arg(name);
- return (createFindResult(NXDOMAIN, ConstRRsetPtr(), false));
+ return (createFindContext(NXDOMAIN, ConstRRsetPtr(), false));
case DomainTree::EXACTMATCH: // This one is OK, handle it
break;
default:
if (node->isEmpty()) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_DOMAIN_EMPTY).
arg(name);
- return (createFindResult(NXRRSET, ConstRRsetPtr(), rename));
+ return (createFindContext(NXRRSET, ConstRRsetPtr(), rename));
}
Domain::const_iterator found;
if (found != node->getData()->end()) {
LOG_DEBUG(logger, DBG_TRACE_DATA,
DATASRC_MEM_EXACT_DELEGATION).arg(name);
- return (FindResult(DELEGATION,
- prepareRRset(name, found->second, rename,
- options)));
+ return (createFindContext(DELEGATION,
+ prepareRRset(name, found->second,
+ rename, options)));
}
}
}
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_ANY_SUCCESS).
arg(name);
- return (createFindResult(SUCCESS, ConstRRsetPtr(), rename));
+ return (createFindContext(SUCCESS, ConstRRsetPtr(), rename));
}
found = node->getData()->find(type);
// Good, it is here
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_SUCCESS).arg(name).
arg(type);
- return (createFindResult(SUCCESS, prepareRRset(name,
- found->second,
- rename, options),
- rename));
+ return (createFindContext(SUCCESS, prepareRRset(name,
+ found->second,
+ rename, options),
+ rename));
} else {
// Next, try CNAME.
found = node->getData()->find(RRType::CNAME());
if (found != node->getData()->end()) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_CNAME).arg(name);
- return (createFindResult(CNAME,
- prepareRRset(name, found->second,
- rename, options),
- rename));
+ return (createFindContext(CNAME,
+ prepareRRset(name, found->second,
+ rename, options),
+ rename));
}
}
// No exact match or CNAME. Return NXRRSET.
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_NXRRSET).arg(type).
arg(name);
- return (createFindResult(NXRRSET, ConstRRsetPtr(), rename));
+ return (createFindContext(NXRRSET, ConstRRsetPtr(), rename));
}
};
return (impl_->zone_class_);
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
InMemoryZoneFinder::find(const Name& name, const RRType& type,
- const FindOptions options)
+ const FindOptions options)
{
return (impl_->find(name, type, NULL, options));
}
-ZoneFinder::FindResult
+ZoneFinderContextPtr
InMemoryZoneFinder::findAll(const Name& name,
std::vector<ConstRRsetPtr>& target,
const FindOptions options)
/// See documentation in \c Zone.
///
/// It returns NULL pointer in case of NXDOMAIN and NXRRSET.
- virtual FindResult find(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- const FindOptions options = FIND_DEFAULT);
+ virtual ZoneFinderContextPtr find(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ const FindOptions options =
+ FIND_DEFAULT);
/// \brief Version of find that returns all types at once
///
/// It acts the same as find, just that when the correct node is found,
/// all the RRsets are filled into the target parameter instead of being
/// returned by the result.
- virtual FindResult findAll(const isc::dns::Name& name,
- std::vector<isc::dns::ConstRRsetPtr>& target,
- const FindOptions options = FIND_DEFAULT);
+ virtual ZoneFinderContextPtr findAll(
+ const isc::dns::Name& name,
+ std::vector<isc::dns::ConstRRsetPtr>& target,
+ const FindOptions options = FIND_DEFAULT);
/// Look for NSEC3 for proving (non)existence of given name.
///
// Confirm at least it doesn't contain any SOA
EXPECT_EQ(ZoneFinder::NXDOMAIN,
- this->getFinder()->find(this->zname_, RRType::SOA()).code);
+ this->getFinder()->find(this->zname_, RRType::SOA())->code);
} catch (const DataSourceError&) {}
ConstRRsetPtr rrset;
const ZoneFinder::FindOptions options = ZoneFinder::FIND_DEFAULT)
{
SCOPED_TRACE("doFindTest " + name.toText() + " " + type.toText());
- const ZoneFinder::FindResult result = finder.find(name, type, options);
- ASSERT_EQ(expected_result, result.code) << name << " " << type;
+ ConstZoneFinderContextPtr result = finder.find(name, type, options);
+ ASSERT_EQ(expected_result, result->code) << name << " " << type;
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_WILDCARD) != 0,
- result.isWildcard());
+ result->isWildcard());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC_SIGNED) != 0,
- result.isNSECSigned());
+ result->isNSECSigned());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC3_SIGNED) != 0,
- result.isNSEC3Signed());
- if (!expected_rdatas.empty() && result.rrset) {
- checkRRset(result.rrset, expected_name != Name(".") ? expected_name :
+ result->isNSEC3Signed());
+ if (!expected_rdatas.empty() && result->rrset) {
+ checkRRset(result->rrset, expected_name != Name(".") ? expected_name :
name, finder.getClass(), expected_type, expected_ttl,
expected_rdatas);
- if (!expected_sig_rdatas.empty() && result.rrset->getRRsig()) {
- checkRRset(result.rrset->getRRsig(), expected_name != Name(".") ?
+ if (!expected_sig_rdatas.empty() && result->rrset->getRRsig()) {
+ checkRRset(result->rrset->getRRsig(), expected_name != Name(".") ?
expected_name : name, finder.getClass(),
isc::dns::RRType::RRSIG(), expected_ttl,
expected_sig_rdatas);
} else if (expected_sig_rdatas.empty()) {
- EXPECT_EQ(isc::dns::RRsetPtr(), result.rrset->getRRsig());
+ EXPECT_EQ(isc::dns::RRsetPtr(), result->rrset->getRRsig());
} else {
ADD_FAILURE() << "Missing RRSIG";
}
} else if (expected_rdatas.empty()) {
- EXPECT_EQ(isc::dns::RRsetPtr(), result.rrset);
+ EXPECT_EQ(isc::dns::RRsetPtr(), result->rrset);
} else {
ADD_FAILURE() << "Missing result";
}
{
SCOPED_TRACE("All test for " + name.toText());
std::vector<ConstRRsetPtr> target;
- ZoneFinder::FindResult result(finder.findAll(name, target, options));
+ ConstZoneFinderContextPtr result(finder.findAll(name, target, options));
EXPECT_TRUE(target.empty());
- EXPECT_EQ(expected_result, result.code);
- EXPECT_EQ(expected_type, result.rrset->getType());
- RdataIteratorPtr it(result.rrset->getRdataIterator());
+ EXPECT_EQ(expected_result, result->code);
+ EXPECT_EQ(expected_type, result->rrset->getType());
+ RdataIteratorPtr it(result->rrset->getRdataIterator());
std::vector<std::string> rdata;
while (!it->isLast()) {
rdata.push_back(it->getCurrent().toText());
}
EXPECT_TRUE(expected_rdata == rdata);
EXPECT_EQ(expected_name == isc::dns::Name::ROOT_NAME() ? name :
- expected_name, result.rrset->getName());
+ expected_name, result->rrset->getName());
}
// When asking for an RRset where RRs somehow have different TTLs, it should
doFindTest(*finder, Name("org"), this->qtype_, this->qtype_,
this->rrttl_, ZoneFinder::NXDOMAIN,
this->empty_rdatas_, this->empty_rdatas_);
- EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("org"), target).code);
+ EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("org"), target)->code);
// sharing a common ancestor
doFindTest(*finder, Name("noexample.org"), this->qtype_, this->qtype_,
this->rrttl_, ZoneFinder::NXDOMAIN,
this->empty_rdatas_, this->empty_rdatas_);
EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("noexample.org"),
- target).code);
+ target)->code);
// totally unrelated domain, smaller number of labels
doFindTest(*finder, Name("com"), this->qtype_, this->qtype_,
this->rrttl_, ZoneFinder::NXDOMAIN,
this->empty_rdatas_, this->empty_rdatas_);
- EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("com"), target).code);
+ EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("com"), target)->code);
// totally unrelated domain, same number of labels
doFindTest(*finder, Name("example.com"), this->qtype_, this->qtype_,
this->rrttl_, ZoneFinder::NXDOMAIN,
this->empty_rdatas_, this->empty_rdatas_);
EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("example.com"),
- target).code);
+ target)->code);
// totally unrelated domain, larger number of labels
doFindTest(*finder, Name("more.example.com"), this->qtype_, this->qtype_,
this->rrttl_, ZoneFinder::NXDOMAIN,
this->empty_rdatas_, this->empty_rdatas_);
EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->findAll(Name("more.example.com"),
- target).code);
+ target)->code);
}
TYPED_TEST(DatabaseClientTest, findDelegation) {
std::vector<ConstRRsetPtr> target;
EXPECT_EQ(ZoneFinder::NXDOMAIN,
finder->findAll(isc::dns::Name("nothere.example.org."),
- target).code);
+ target)->code);
EXPECT_TRUE(target.empty());
EXPECT_EQ(ZoneFinder::NXRRSET,
finder->findAll(isc::dns::Name("here.wild.example.org."),
- target).code);
+ target)->code);
this->expected_rdatas_.push_back("ns.delegation.example.org.");
this->expected_rdatas_.push_back("ns.example.com.");
doFindAllTestResult(*finder, isc::dns::Name("xx.delegation.example.org."),
// It should get the data on success
EXPECT_EQ(ZoneFinder::SUCCESS,
finder->findAll(isc::dns::Name("www2.example.org."),
- target).code);
+ target)->code);
ASSERT_EQ(2, target.size());
size_t a_idx(target[1]->getType() == RRType::A());
EXPECT_EQ(RRType::A(), target[a_idx]->getType());
// And on wildcard. Check the signatures as well.
target.clear();
- const ZoneFinder::FindResult result =
+ ConstZoneFinderContextPtr result =
finder->findAll(Name("a.wild.example.org"), target,
ZoneFinder::FIND_DNSSEC);
- EXPECT_EQ(ZoneFinder::SUCCESS, result.code);
- EXPECT_TRUE(result.isWildcard());
- EXPECT_TRUE(result.isNSECSigned());
- EXPECT_FALSE(result.isNSEC3Signed());
+ EXPECT_EQ(ZoneFinder::SUCCESS, result->code);
+ EXPECT_TRUE(result->isWildcard());
+ EXPECT_TRUE(result->isNSECSigned());
+ EXPECT_FALSE(result->isNSEC3Signed());
ASSERT_EQ(2, target.size());
a_idx = target[1]->getType() == RRType::A();
EXPECT_EQ(RRType::A(), target[a_idx]->getType());
// Before update, the name exists.
EXPECT_EQ(ZoneFinder::SUCCESS, finder->find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
// start update in the replace mode. the normal finder should still
// be able to see the record, but the updater's finder shouldn't.
this->updater_ = this->client_->getUpdater(this->zname_, true);
this->setUpdateAccessor();
EXPECT_EQ(ZoneFinder::SUCCESS,
- finder->find(this->qname_, this->qtype_).code);
+ finder->find(this->qname_, this->qtype_)->code);
EXPECT_EQ(ZoneFinder::NXDOMAIN,
this->updater_->getFinder().find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
// commit the update. now the normal finder shouldn't see it.
this->updater_->commit();
EXPECT_EQ(ZoneFinder::NXDOMAIN, finder->find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
// Check rollback wasn't accidentally performed.
EXPECT_FALSE(this->isRollbacked());
ZoneFinderPtr finder = this->client_->findZone(this->zname_).zone_finder;
EXPECT_EQ(ZoneFinder::SUCCESS, finder->find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
this->updater_ = this->client_->getUpdater(this->zname_, true);
this->setUpdateAccessor();
EXPECT_EQ(ZoneFinder::NXDOMAIN,
this->updater_->getFinder().find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
// DB should not have been rolled back yet.
EXPECT_FALSE(this->isRollbacked());
this->updater_.reset(); // destruct without commit
// isRollbacked())
EXPECT_TRUE(this->isRollbacked(true));
EXPECT_EQ(ZoneFinder::SUCCESS, finder->find(this->qname_,
- this->qtype_).code);
+ this->qtype_)->code);
}
TYPED_TEST(DatabaseClientTest, exceptionFromRollback) {
// The whole block is inside, because we need to check the result and
// we can't assign to FindResult
EXPECT_NO_THROW({
- ZoneFinder::FindResult find_result(zone_finder->find(
- name, rrtype, options));
+ ZoneFinderContextPtr find_result(zone_finder->find(
+ name, rrtype, options));
// Check it returns correct answers
- EXPECT_EQ(result, find_result.code);
+ EXPECT_EQ(result, find_result->code);
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_WILDCARD) != 0,
- find_result.isWildcard());
+ find_result->isWildcard());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC_SIGNED)
- != 0, find_result.isNSECSigned());
+ != 0, find_result->isNSECSigned());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC3_SIGNED)
- != 0, find_result.isNSEC3Signed());
+ != 0, find_result->isNSEC3Signed());
if (check_answer) {
if (!answer) {
- ASSERT_FALSE(find_result.rrset);
+ ASSERT_FALSE(find_result->rrset);
} else {
- ASSERT_TRUE(find_result.rrset);
- rrsetCheck(answer, find_result.rrset);
+ ASSERT_TRUE(find_result->rrset);
+ rrsetCheck(answer, find_result->rrset);
if (answer_sig) {
- ASSERT_TRUE(find_result.rrset->getRRsig());
+ ASSERT_TRUE(find_result->rrset->getRRsig());
rrsetCheck(answer_sig,
- find_result.rrset->getRRsig());
+ find_result->rrset->getRRsig());
}
}
} else if (check_wild_answer) {
ASSERT_NE(ConstRRsetPtr(), answer) <<
"Wrong test, don't check for wild names if you expect "
"empty answer";
- ASSERT_NE(ConstRRsetPtr(), find_result.rrset) <<
+ ASSERT_NE(ConstRRsetPtr(), find_result->rrset) <<
"No answer found";
// Build the expected answer using the given name and
// other parameter of the base wildcard RRset.
for (; !expectedIt->isLast(); expectedIt->next()) {
wildanswer->addRdata(expectedIt->getCurrent());
}
- rrsetCheck(wildanswer, find_result.rrset);
+ rrsetCheck(wildanswer, find_result->rrset);
// Same for the RRSIG, if any.
if (answer_sig) {
- ASSERT_TRUE(find_result.rrset->getRRsig());
+ ASSERT_TRUE(find_result->rrset->getRRsig());
RRsetPtr wildsig(new RRset(name,
answer_sig->getClass(),
for (; !expectedIt->isLast(); expectedIt->next()) {
wildsig->addRdata(expectedIt->getCurrent());
}
- rrsetCheck(wildsig, find_result.rrset->getRRsig());
+ rrsetCheck(wildsig, find_result->rrset->getRRsig());
}
}
});
finder = &zone_finder_;
}
std::vector<ConstRRsetPtr> target;
- ZoneFinder::FindResult find_result(finder->findAll(name, target,
- options));
- EXPECT_EQ(result, find_result.code);
+ ZoneFinderContextPtr find_result(finder->findAll(name, target,
+ options));
+ EXPECT_EQ(result, find_result->code);
if (!rrset_result) {
- EXPECT_FALSE(find_result.rrset);
+ EXPECT_FALSE(find_result->rrset);
} else {
- ASSERT_TRUE(find_result.rrset);
- rrsetCheck(rrset_result, find_result.rrset);
+ ASSERT_TRUE(find_result->rrset);
+ rrsetCheck(rrset_result, find_result->rrset);
}
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_WILDCARD) != 0,
- find_result.isWildcard());
+ find_result->isWildcard());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC_SIGNED)
- != 0, find_result.isNSECSigned());
+ != 0, find_result->isNSECSigned());
EXPECT_EQ((expected_flags & ZoneFinder::RESULT_NSEC3_SIGNED)
- != 0, find_result.isNSEC3Signed());
+ != 0, find_result->isNSEC3Signed());
rrsetsCheck(expected_rrsets.begin(), expected_rrsets.end(),
target.begin(), target.end());
}
// that covers the first RRset
zone_finder_.add(rr_a_);
zone_finder_.add(textToRRset(rrsig_a_txt));
- ZoneFinder::FindResult result = zone_finder_.find(origin_, RRType::A(),
- ZoneFinder::FIND_DNSSEC);
- EXPECT_EQ(ZoneFinder::SUCCESS, result.code);
- ASSERT_TRUE(result.rrset);
- ASSERT_TRUE(result.rrset->getRRsig());
- actual_rrsets_.push_back(result.rrset->getRRsig());
+ ZoneFinderContextPtr result = zone_finder_.find(origin_, RRType::A(),
+ ZoneFinder::FIND_DNSSEC);
+ EXPECT_EQ(ZoneFinder::SUCCESS, result->code);
+ ASSERT_TRUE(result->rrset);
+ ASSERT_TRUE(result->rrset->getRRsig());
+ actual_rrsets_.push_back(result->rrset->getRRsig());
rrsetsCheck(rrsig_a_txt, actual_rrsets_.begin(), actual_rrsets_.end());
// Confirm a separate RRISG for a different type can be added
actual_rrsets_.clear();
zone_finder_.add(rr_ns_);
zone_finder_.add(textToRRset(rrsig_ns_txt));
- ZoneFinder::FindResult result2 =
- zone_finder_.find(origin_, RRType::NS(), ZoneFinder::FIND_DNSSEC);
- EXPECT_EQ(ZoneFinder::SUCCESS, result2.code);
- ASSERT_TRUE(result2.rrset);
- ASSERT_TRUE(result2.rrset->getRRsig());
- actual_rrsets_.push_back(result2.rrset->getRRsig());
+ result = zone_finder_.find(origin_, RRType::NS(), ZoneFinder::FIND_DNSSEC);
+ EXPECT_EQ(ZoneFinder::SUCCESS, result->code);
+ ASSERT_TRUE(result->rrset);
+ ASSERT_TRUE(result->rrset->getRRsig());
+ actual_rrsets_.push_back(result->rrset->getRRsig());
rrsetsCheck(rrsig_ns_txt, actual_rrsets_.begin(), actual_rrsets_.end());
// Check a case with multiple RRSIGs
actual_rrsets_.clear();
zone_finder_.add(rr_ns_aaaa_);
zone_finder_.add(textToRRset(rrsig_aaaa_txt));
- ZoneFinder::FindResult result3 =
- zone_finder_.find(Name("ns.example.org"), RRType::AAAA(),
- ZoneFinder::FIND_DNSSEC);
- EXPECT_EQ(ZoneFinder::SUCCESS, result3.code);
- ASSERT_TRUE(result3.rrset);
- ASSERT_TRUE(result3.rrset->getRRsig());
- actual_rrsets_.push_back(result3.rrset->getRRsig());
+ result = zone_finder_.find(Name("ns.example.org"), RRType::AAAA(),
+ ZoneFinder::FIND_DNSSEC);
+ EXPECT_EQ(ZoneFinder::SUCCESS, result->code);
+ ASSERT_TRUE(result->rrset);
+ ASSERT_TRUE(result->rrset->getRRsig());
+ actual_rrsets_.push_back(result->rrset->getRRsig());
rrsetsCheck(rrsig_aaaa_txt, actual_rrsets_.begin(), actual_rrsets_.end());
}
EXPECT_EQ(result::SUCCESS, zone_finder_.add(textToRRset(nsec3_text)));
EXPECT_EQ(ZoneFinder::NXDOMAIN,
zone_finder_.find(Name(string(apex_hash) + ".example.org"),
- RRType::NSEC3()).code);
+ RRType::NSEC3())->code);
// Dedicated NSEC3 find should be able to find it.
findNSEC3Check(true, origin_.getLabelCount(), nsec3_text, "",
zone_finder_.findNSEC3(Name("example.org"), false));
EXPECT_EQ(result::SUCCESS, zone_finder_.add(textToRRset(nonsec3_text)));
EXPECT_EQ(ZoneFinder::SUCCESS,
zone_finder_.find(Name(string(apex_hash) + ".example.org"),
- RRType::A()).code);
+ RRType::A())->code);
}
TEST_F(InMemoryZoneFinderTest, addNSEC3Lower) {
#ifndef __ZONE_H
#define __ZONE_H 1
-#include <utility>
-#include <vector>
-
#include <dns/rrset.h>
#include <dns/rrsetlist.h>
#include <datasrc/result.h>
+#include <utility>
+#include <vector>
+
namespace isc {
namespace datasrc {
/// proof of the result.
///
/// The caller is generally expected to get access to the information
- /// via read-only getter methods of \c FindResult so that it won't rely
+ /// via read-only getter methods of \c FindContext so that it won't rely
/// on specific details of the representation of the flags. So these
/// definitions are basically only meaningful for data source
/// implementations.
///
/// Note: we may also want to include the closest enclosure "node" to
/// optimize including the NSEC for no-wildcard proof (FWIW NSD does that).
- struct FindResult {
- FindResult(Result param_code,
- const isc::dns::ConstRRsetPtr param_rrset,
- FindResultFlags param_flags = RESULT_DEFAULT) :
+ class Context {
+ public:
+ Context(Result param_code,
+ const isc::dns::ConstRRsetPtr param_rrset,
+ FindResultFlags param_flags = RESULT_DEFAULT) :
code(param_code), rrset(param_rrset), flags(param_flags)
{}
const Result code;
/// the code of \c DNAME and that DNAME RR.
///
/// No RRset will be returned in the \c NXDOMAIN and \c NXRRSET cases
- /// (\c rrset member of \c FindResult will be NULL), unless DNSSEC data
+ /// (\c rrset member of \c FindContext will be NULL), unless DNSSEC data
/// are required. See below for the cases with DNSSEC.
///
- /// The returned \c FindResult object can also provide supplemental
+ /// The returned \c FindContext object can also provide supplemental
/// information about the search result via its methods returning a
/// boolean value. Such information may be useful for the caller if
/// the caller wants to collect additional DNSSEC proofs based on the
/// returned from this method.
///
/// In case it's signed with NSEC, this method will possibly return
- /// a related NSEC RRset in the \c rrset member of \c FindResult.
+ /// a related NSEC RRset in the \c rrset member of \c FindContext.
/// What kind of NSEC is returned depends on the result code
/// (\c NXDOMAIN or \c NXRRSET) and on whether it's a wildcard match:
///
/// \endcode
/// a call to \c find() for "y.b.example.org" with FIND_DNSSEC will
/// result in NXRRSET and this NSEC; \c isWildcard() on the returned
- /// \c FindResult object will return true.
+ /// \c FindContext object will return true.
///
/// \exception std::bad_alloc Memory allocation such as for constructing
/// the resulting RRset fails
/// \param name The domain name to be searched for.
/// \param type The RR type to be searched for.
/// \param options The search options.
- /// \return A \c FindResult object enclosing the search result (see above).
- virtual FindResult find(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- const FindOptions options
- = FIND_DEFAULT) = 0;
+ /// \return A \c FindContext object enclosing the search result
+ /// (see above).
+ virtual boost::shared_ptr<Context> find(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ const FindOptions options
+ = FIND_DEFAULT) = 0;
///
/// \brief Finds all RRsets in the given name.
/// \param target the successfull result is returned through this
/// \param options \see find, parameter options
/// \return \see find and it's result
- virtual FindResult findAll(const isc::dns::Name& name,
- std::vector<isc::dns::ConstRRsetPtr> &target,
- const FindOptions options = FIND_DEFAULT) = 0;
+ virtual boost::shared_ptr<Context> findAll(
+ const isc::dns::Name& name,
+ std::vector<isc::dns::ConstRRsetPtr> &target,
+ const FindOptions options = FIND_DEFAULT) = 0;
/// A helper structure to represent the search result of \c findNSEC3().
///
- /// The idea is similar to that of \c FindResult, but \c findNSEC3() has
+ /// The idea is similar to that of \c FindContext, but \c findNSEC3() has
/// special interface and semantics, we use a different structure to
/// represent the result.
struct FindNSEC3Result {
/// \brief A pointer-like type pointing to a \c ZoneFinder object.
typedef boost::shared_ptr<ZoneFinder> ZoneFinderPtr;
-/// \brief A pointer-like type pointing to a \c ZoneFinder object.
+/// \brief A pointer-like type pointing to an immutable \c ZoneFinder object.
typedef boost::shared_ptr<const ZoneFinder> ConstZoneFinderPtr;
+/// \brief A pointer-like type pointing to a \c ZoneFinder::Context object.
+typedef boost::shared_ptr<ZoneFinder::Context> ZoneFinderContextPtr;
+
+/// \brief A pointer-like type pointing to an immutable
+/// \c ZoneFinder::Context object.
+typedef boost::shared_ptr<ZoneFinder::Context> ConstZoneFinderContextPtr;
+
/// The base class to make updates to a single zone.
///
/// On construction, each derived class object will start a "transaction"
namespace {
ZoneFinder::FindResultFlags
-getFindResultFlags(const ZoneFinder::FindResult& result) {
+getFindResultFlags(const ZoneFinder::Context& context) {
ZoneFinder::FindResultFlags result_flags = ZoneFinder::RESULT_DEFAULT;
- if (result.isWildcard()) {
+ if (context.isWildcard()) {
result_flags = result_flags | ZoneFinder::RESULT_WILDCARD;
}
- if (result.isNSECSigned()) {
+ if (context.isNSECSigned()) {
result_flags = result_flags | ZoneFinder::RESULT_NSEC_SIGNED;
}
- if (result.isNSEC3Signed()) {
+ if (context.isNSEC3Signed()) {
result_flags = result_flags | ZoneFinder::RESULT_NSEC3_SIGNED;
}
return (result_flags);
try {
ZoneFinder::FindOptions options =
static_cast<ZoneFinder::FindOptions>(options_int);
- const ZoneFinder::FindResult find_result(
+ ConstZoneFinderContextPtr find_ctx(
finder->find(PyName_ToName(name), PyRRType_ToRRType(rrtype),
options));
- const ZoneFinder::Result r = find_result.code;
- isc::dns::ConstRRsetPtr rrsp = find_result.rrset;
+ const ZoneFinder::Result r = find_ctx->code;
+ isc::dns::ConstRRsetPtr rrsp = find_ctx->rrset;
ZoneFinder::FindResultFlags result_flags =
- getFindResultFlags(find_result);
+ getFindResultFlags(*find_ctx);
if (rrsp) {
// Use N instead of O so the refcount isn't increased twice
return (Py_BuildValue("INI", r, createRRsetObject(*rrsp),
ZoneFinder::FindOptions options =
static_cast<ZoneFinder::FindOptions>(options_int);
std::vector<isc::dns::ConstRRsetPtr> target;
- const ZoneFinder::FindResult find_result(
+ ConstZoneFinderContextPtr find_ctx(
finder->findAll(PyName_ToName(name), target, options));
- const ZoneFinder::Result r = find_result.code;
- isc::dns::ConstRRsetPtr rrsp = find_result.rrset;
+ const ZoneFinder::Result r = find_ctx->code;
+ isc::dns::ConstRRsetPtr rrsp = find_ctx->rrset;
ZoneFinder::FindResultFlags result_flags =
- getFindResultFlags(find_result);
+ getFindResultFlags(*find_ctx);
if (r == ZoneFinder::SUCCESS) {
// Copy all the RRsets to the result list
PyObjectContainer list_container(PyList_New(target.size()));
projects / thirdparty / kea.git / commitdiff
