|
|
@@ -168,48 +168,25 @@ public:
|
|
|
/// can define a derived class of the base Context and override the
|
|
|
/// specific virtual method.
|
|
|
///
|
|
|
+ /// This base class defines these common protected methods along with
|
|
|
+ /// some helper pure virtual methods that would be necessary for the
|
|
|
+ /// common methods. If a derived class wants to use the common version
|
|
|
+ /// of the protected method, it needs to provide expected result through
|
|
|
+ /// their implementation of the pure virtual methods.
|
|
|
+ ///
|
|
|
/// This class object is generally expected to be associated with the
|
|
|
/// ZoneFinder that originally performed the \c find() call, and expects
|
|
|
/// the finder is valid throughout the lifetime of this object. It's
|
|
|
/// caller's responsibility to ensure that assumption.
|
|
|
class Context {
|
|
|
public:
|
|
|
- /// \brief The constructor for the normal find call.
|
|
|
- ///
|
|
|
- /// This constructor is expected to be called from the \c find()
|
|
|
- /// method when it constructs the return value.
|
|
|
+ /// \brief The constructor.
|
|
|
///
|
|
|
- /// \param finder The ZoneFinder on which find() is called.
|
|
|
/// \param options The find options specified for the find() call.
|
|
|
/// \param result The result of the find() call.
|
|
|
- Context(ZoneFinder& finder, FindOptions options,
|
|
|
- const ResultContext& result) :
|
|
|
+ Context(FindOptions options, const ResultContext& result) :
|
|
|
code(result.code), rrset(result.rrset),
|
|
|
- finder_(finder), flags_(result.flags), options_(options)
|
|
|
- {}
|
|
|
-
|
|
|
- /// \brief The constructor for the normal findAll call.
|
|
|
- ///
|
|
|
- /// This constructor is expected to be called from the \c findAll()
|
|
|
- /// method when it constructs the return value.
|
|
|
- ///
|
|
|
- /// It copies the vector that is to be returned to the caller of
|
|
|
- /// \c findAll() for possible subsequent use. Note that it cannot
|
|
|
- /// simply hold a reference to the vector because the caller may
|
|
|
- /// alter it after the \c findAll() call.
|
|
|
- ///
|
|
|
- /// \param finder The ZoneFinder on which findAll() is called.
|
|
|
- /// \param options The find options specified for the findAll() call.
|
|
|
- /// \param result The result of the findAll() call (whose rrset is
|
|
|
- /// expected to be NULL).
|
|
|
- /// \param all_set Reference to the vector given by the caller of
|
|
|
- /// \c findAll(), storing the RRsets to be returned.
|
|
|
- Context(ZoneFinder& finder, FindOptions options,
|
|
|
- const ResultContext& result,
|
|
|
- const std::vector<isc::dns::ConstRRsetPtr> &all_set) :
|
|
|
- code(result.code), rrset(result.rrset),
|
|
|
- finder_(finder), flags_(result.flags), options_(options),
|
|
|
- all_set_(all_set)
|
|
|
+ flags_(result.flags), options_(options)
|
|
|
{}
|
|
|
|
|
|
/// \brief The destructor.
|
|
|
@@ -291,22 +268,181 @@ public:
|
|
|
getAdditionalImpl(requested_types, result);
|
|
|
}
|
|
|
|
|
|
+ /// \brief Find and return given type of RRset at the zone origin.
|
|
|
+ ///
|
|
|
+ /// DNS query processing often requires supplemental RRsets at the
|
|
|
+ /// zone origin; for example, for some negative answers we need to
|
|
|
+ /// provide the zone's SOA record; a full positive response normally
|
|
|
+ /// includes the zone's NS RRset. The application can easily get
|
|
|
+ /// these using the generic \c ZoneFinder::find() interface, but
|
|
|
+ /// depending on the underlying data source implementation, the generic
|
|
|
+ /// version could be more expensive and/or it might be possible to
|
|
|
+ /// substantially improve this particular case.
|
|
|
+ ///
|
|
|
+ /// This method allows the underlying implementation to do such
|
|
|
+ /// optimization. The interface is simplified; it just takes
|
|
|
+ /// an `RRType` and returns the corresponding RRset if found;
|
|
|
+ /// if not found it returns NULL.
|
|
|
+ ///
|
|
|
+ /// This method tries to find and return RRSIGs of the found RRset
|
|
|
+ /// if and only if the original lookup by \c ZoneFinder::find() has
|
|
|
+ /// the \c FIND_DNSSEC option.
|
|
|
+ ///
|
|
|
+ /// Type ANY must not be specified for this method. It will result
|
|
|
+ /// in \c isc::InvalidParameter exception. If the application
|
|
|
+ /// needs to get all types of RRsets at the origin, it should use
|
|
|
+ /// the \c ZoneFinder::findAll() method with the zone name.
|
|
|
+ ///
|
|
|
+ /// Note that the origin name should always exist, so there
|
|
|
+ /// shouldn't be the case where the name itself is not found
|
|
|
+ /// in the zone (i.e., the NXDOMAIN) case. But in any event
|
|
|
+ /// it does not distinguish such a hypothetical case from the
|
|
|
+ /// case where the specified type isn't found at the origin.
|
|
|
+ /// It simply returns NULL when the required type isn't found.
|
|
|
+ /// This also means it doesn't provide a DNSSEC proof of the
|
|
|
+ /// non-existence. If the application needs that proof, it must use
|
|
|
+ /// the generic \c find() method.
|
|
|
+ ///
|
|
|
+ /// A CNAME RR shouldn't exist at the zone origin at any sanely
|
|
|
+ /// configured zone (because there should be at least SOA there and
|
|
|
+ /// CNAME cannot coexist with it), and it's generally expected
|
|
|
+ /// the underlying implementation rejects the case where a CNAME
|
|
|
+ /// somehow exists at the zone origin. Even if such a situation
|
|
|
+ /// happens, this method does not return the CNAME when the given
|
|
|
+ /// type of RRset isn't found; it will just return NULL like in the
|
|
|
+ /// normal case.
|
|
|
+ ///
|
|
|
+ /// \throw isc::InvalidParameter Type ANY is specified
|
|
|
+ /// \throw std::bad_alloc Internal resource allocation failure
|
|
|
+ ///
|
|
|
+ /// \param type The RR type for which an RRset at the origin is to be
|
|
|
+ /// found.
|
|
|
+ /// \return A shared pointer to the requested type of RRset or NULL
|
|
|
+ /// if not found.
|
|
|
+ dns::ConstRRsetPtr getAtOrigin(const dns::RRType& type) {
|
|
|
+ // Perform common check, then delegate the actual work to
|
|
|
+ // derived class implementation, if provided.
|
|
|
+ if (type == dns::RRType::ANY()) {
|
|
|
+ isc_throw(isc::InvalidParameter,
|
|
|
+ "Type ANY isn't allowed for getAtOrigin");
|
|
|
+ }
|
|
|
+ return (getAtOriginImpl(type));
|
|
|
+ }
|
|
|
+
|
|
|
protected:
|
|
|
+ /// \brief Return the \c ZoneFinder that created this \c Context.
|
|
|
+ ///
|
|
|
+ /// A derived class implementation can return NULL if it defines
|
|
|
+ /// other protected methods that require a non NULL result from
|
|
|
+ /// this method. Otherwise it must return a valid, non NULL pointer
|
|
|
+ /// to the \c ZoneFinder object.
|
|
|
+ ///
|
|
|
+ /// When returning non NULL, the ownership of the pointed object
|
|
|
+ /// was not transferred to the caller; it cannot be assumed to be
|
|
|
+ /// valid after the originating \c Context object is destroyed.
|
|
|
+ /// Also, the caller must not try to delete the returned object.
|
|
|
+ virtual ZoneFinder* getFinder() = 0;
|
|
|
+
|
|
|
+ /// \brief Return a vector of RRsets corresponding to findAll() result.
|
|
|
+ ///
|
|
|
+ /// This method returns a set of RRsets that correspond to the
|
|
|
+ /// returned RRsets to a prior \c findAll() call.
|
|
|
+ ///
|
|
|
+ /// A derived class implementation can return NULL if it defines
|
|
|
+ /// other protected methods that require a non NULL result from
|
|
|
+ /// this method. Otherwise it must return a valid, non NULL pointer
|
|
|
+ /// to a vector that correspond to the expected set of RRsets.
|
|
|
+ ///
|
|
|
+ /// When returning non NULL, the ownership of the pointed object
|
|
|
+ /// was not transferred to the caller; it cannot be assumed to be
|
|
|
+ /// valid after the originating \c Context object is destroyed.
|
|
|
+ /// Also, the caller must not try to delete the returned object.
|
|
|
+ virtual const std::vector<isc::dns::ConstRRsetPtr>*
|
|
|
+ getAllRRsets() const = 0;
|
|
|
+
|
|
|
/// \brief Actual implementation of getAdditional().
|
|
|
///
|
|
|
/// This base class defines a default implementation that can be
|
|
|
/// used for any type of data sources. A data source implementation
|
|
|
/// can override it.
|
|
|
+ ///
|
|
|
+ /// The default version of this implementation requires both
|
|
|
+ /// \c getFinder() and \c getAllRRsets() return valid results.
|
|
|
virtual void getAdditionalImpl(
|
|
|
const std::vector<isc::dns::RRType>& requested_types,
|
|
|
std::vector<isc::dns::ConstRRsetPtr>& result);
|
|
|
|
|
|
+ /// \brief Actual implementation of getAtOrigin().
|
|
|
+ ///
|
|
|
+ /// This base class defines a default implementation that can be
|
|
|
+ /// used for any type of data sources. A data source implementation
|
|
|
+ /// can override it.
|
|
|
+ ///
|
|
|
+ /// The default version of this implementation requires
|
|
|
+ /// \c getFinder() return a valid result.
|
|
|
+ virtual dns::ConstRRsetPtr getAtOriginImpl(const dns::RRType& type);
|
|
|
+
|
|
|
private:
|
|
|
- ZoneFinder& finder_;
|
|
|
+
|
|
|
const FindResultFlags flags_;
|
|
|
protected:
|
|
|
const FindOptions options_;
|
|
|
+ };
|
|
|
+
|
|
|
+ /// \brief Generic ZoneFinder context that works for all implementations.
|
|
|
+ ///
|
|
|
+ /// This is a concrete derived class of \c ZoneFinder::Context that
|
|
|
+ /// only use the generic (default) versions of the protected methods
|
|
|
+ /// and therefore work for any data source implementation.
|
|
|
+ ///
|
|
|
+ /// A data source implementation can use this class to create a
|
|
|
+ /// \c Context object as a return value of \c find() or \c findAll()
|
|
|
+ /// method if it doesn't have to optimize specific protected methods.
|
|
|
+ class GenericContext : public Context {
|
|
|
+ public:
|
|
|
+ /// \brief The constructor for the normal find call.
|
|
|
+ ///
|
|
|
+ /// This constructor is expected to be called from the \c find()
|
|
|
+ /// method when it constructs the return value.
|
|
|
+ ///
|
|
|
+ /// \param finder The ZoneFinder on which find() is called.
|
|
|
+ /// \param options See the \c Context class.
|
|
|
+ /// \param result See the \c Context class.
|
|
|
+ GenericContext(ZoneFinder& finder, FindOptions options,
|
|
|
+ const ResultContext& result) :
|
|
|
+ Context(options, result), finder_(finder)
|
|
|
+ {}
|
|
|
+
|
|
|
+ /// \brief The constructor for the normal findAll call.
|
|
|
+ ///
|
|
|
+ /// This constructor is expected to be called from the \c findAll()
|
|
|
+ /// method when it constructs the return value.
|
|
|
+ ///
|
|
|
+ /// It copies the vector that is to be returned to the caller of
|
|
|
+ /// \c findAll() for possible subsequent use. Note that it cannot
|
|
|
+ /// simply hold a reference to the vector because the caller may
|
|
|
+ /// alter it after the \c findAll() call.
|
|
|
+ ///
|
|
|
+ /// \param finder The ZoneFinder on which findAll() is called.
|
|
|
+ /// \param options See the \c Context class.
|
|
|
+ /// \param result See the \c Context class.
|
|
|
+ /// \param all_set Reference to the vector given by the caller of
|
|
|
+ /// \c findAll(), storing the RRsets to be returned.
|
|
|
+ GenericContext(ZoneFinder& finder, FindOptions options,
|
|
|
+ const ResultContext& result,
|
|
|
+ const std::vector<isc::dns::ConstRRsetPtr>& all_set) :
|
|
|
+ Context(options, result), finder_(finder), all_set_(all_set)
|
|
|
+ {}
|
|
|
+
|
|
|
+ protected:
|
|
|
+ virtual ZoneFinder* getFinder() { return (&finder_); }
|
|
|
+ virtual const std::vector<isc::dns::ConstRRsetPtr>*
|
|
|
+ getAllRRsets() const {
|
|
|
+ return (&all_set_);
|
|
|
+ }
|
|
|
+
|
|
|
private:
|
|
|
+ ZoneFinder& finder_;
|
|
|
std::vector<isc::dns::ConstRRsetPtr> all_set_;
|
|
|
};
|
|
|
|
JINMEI Tatuya