validation-state.hpp

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

#include <set>
#include "validation-error.hpp"
#include "certificate-v2.hpp"
#include "../../interest.hpp"

namespace ndn {

typedef func_lib::function<void(const Data& data)> DataValidationSuccessCallback;

typedef func_lib::function<void
  (const Data& data, const ValidationError& error)> DataValidationFailureCallback;

typedef func_lib::function<void
  (const Interest& interest)> InterestValidationSuccessCallback;

typedef func_lib::function<void
  (const Interest& interest, const ValidationError& error)>
  InterestValidationFailureCallback;

class ValidationState {
public:
  ValidationState()
  : hasOutcome_(false)
  {
  }

  virtual
  ~ValidationState();

  bool
  hasOutcome() { return hasOutcome_; }

  bool
  isOutcomeFailed() { return hasOutcome_ && outcome_ == false; }

  bool
  isOutcomeSuccess() { return hasOutcome_ && outcome_ == true; }

  virtual void
  fail(const ValidationError& error) = 0;

  size_t
  getDepth() const { return certificateChain_.size(); }

  bool
  hasSeenCertificateName(const Name& certificateName)
  {
    // second is false if certificateName was already in the set.
    return !seenCertificateNames_.insert(certificateName).second;
  }

  void
  addCertificate(const CertificateV2& certificate)
  {
    certificateChain_.insert
      (certificateChain_.begin(),
       ptr_lib::make_shared<CertificateV2>(certificate));
  }

protected:
  void
  setOutcome(bool outcome);

private:
  friend class Validator;

  virtual void
  verifyOriginalPacket(const CertificateV2& trustedCertificate) = 0;

  virtual void
  bypassValidation() = 0;

  ptr_lib::shared_ptr<CertificateV2>
  verifyCertificateChain
    (const ptr_lib::shared_ptr<CertificateV2>& trustedCertificate);

  // Disable the copy constructor and assignment operator.
  ValidationState(const ValidationState& other);
  ValidationState& operator=(const ValidationState& other);

  std::vector<ptr_lib::shared_ptr<CertificateV2> > certificateChain_;
  std::set<Name> seenCertificateNames_;
  bool hasOutcome_;
  bool outcome_;
};

class DataValidationState : public ValidationState {
public:
  DataValidationState
    (const Data& data, const DataValidationSuccessCallback& successCallback,
     const DataValidationFailureCallback& failureCallback);

  // TODO: Checks in ~DataValidationState.

  virtual void
  fail(const ValidationError& error);

  const Data&
  getOriginalData() const { return data_; }

private:
  virtual void
  verifyOriginalPacket(const CertificateV2& trustedCertificate);

  virtual void
  bypassValidation();

  Data data_;
  DataValidationSuccessCallback successCallback_;
  DataValidationFailureCallback failureCallback_;
};

class InterestValidationState : public ValidationState {
public:
  InterestValidationState
    (const Interest& interest,
     const InterestValidationSuccessCallback& successCallback,
     const InterestValidationFailureCallback& failureCallback);

  // TODO: Checks in ~InterestValidationState.

  virtual void
  fail(const ValidationError& error);

  const Interest&
  getOriginalInterest() const { return interest_; }

  void
  addSuccessCallback(const InterestValidationSuccessCallback& successCallback)
  {
    successCallbacks_.push_back(successCallback);
  }

private:
  virtual void
  verifyOriginalPacket(const CertificateV2& trustedCertificate);

  virtual void
  bypassValidation();

  Interest interest_;
  std::vector<InterestValidationSuccessCallback> successCallbacks_;
  InterestValidationFailureCallback failureCallback_;
};

}

#endif