validator.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_VALIDATOR_HPP
#define NDN_VALIDATOR_HPP

#include "certificate-fetcher-offline.hpp"
#include "validation-policy.hpp"

namespace ndn {

class Validator : public CertificateStorage {
public:
  Validator
    (const ptr_lib::shared_ptr<ValidationPolicy>& policy,
     const ptr_lib::shared_ptr<CertificateFetcher>& certificateFetcher =
       ptr_lib::make_shared<CertificateFetcherOffline>());

  ValidationPolicy&
  getPolicy() { return *policy_; }

  CertificateFetcher&
  getFetcher() { return *certificateFetcher_; }

  void
  setMaxDepth(size_t maxDepth) { maxDepth_ = maxDepth; }

  size_t
  getMaxDepth() const { return maxDepth_; }

  void
  validate
    (const Data& data, const DataValidationSuccessCallback& successCallback,
     const DataValidationFailureCallback& failureCallback);

  void
  validate
    (const Interest& interest,
     const InterestValidationSuccessCallback& successCallback,
     const InterestValidationFailureCallback& failureCallback);

private:
  void
  validateCertificate
    (const ptr_lib::shared_ptr<CertificateV2>& certificate,
     const ptr_lib::shared_ptr<ValidationState>& state);

  void
  requestCertificate
    (const ptr_lib::shared_ptr<CertificateRequest>& certificateRequest,
     const ptr_lib::shared_ptr<ValidationState>& state);

  void
  continueValidateCertificate
    (const ptr_lib::shared_ptr<CertificateRequest>& certificateRequest,
     const ptr_lib::shared_ptr<ValidationState>& state,
     const ptr_lib::shared_ptr<CertificateV2>& certificate)
  {
    if (!certificateRequest)
      state->fail(ValidationError
        (ValidationError::POLICY_ERROR,
         "Validation policy is not allowed to designate `" +
         certificate->getName().toUri() + "` as a trust anchor"));
    else {
      // We need to fetch the key and validate it.
      state->addCertificate(*certificate);
      requestCertificate(certificateRequest, state);
    }
  }

  void
  continueValidate
    (const ptr_lib::shared_ptr<CertificateRequest>& certificateRequest,
     const ptr_lib::shared_ptr<ValidationState>& state)
  {
    if (!certificateRequest)
      state->bypassValidation();
    else
      // We need to fetch the key and validate it.
      requestCertificate(certificateRequest, state);
  }

  ptr_lib::shared_ptr<ValidationPolicy> policy_;
  ptr_lib::shared_ptr<CertificateFetcher> certificateFetcher_;
  size_t maxDepth_;
};

}

#endif