rule.cpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2021 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */
 
#include "ndn-cxx/security/validator-config/rule.hpp"
#include "ndn-cxx/security/validation-state.hpp"
#include "ndn-cxx/util/logger.hpp"
 
#include <boost/algorithm/string/predicate.hpp>
 
NDN_LOG_INIT(ndn.security.validator_config.Rule);
 
namespace ndn {
namespace security {
inline namespace v2 {
namespace validator_config {
 
Rule::Rule(const std::string& id, uint32_t pktType)
  : m_id(id)
  , m_pktType(pktType)
{
}
 
void
Rule::addFilter(unique_ptr<Filter> filter)
{
  m_filters.push_back(std::move(filter));
}
 
void
Rule::addChecker(unique_ptr<Checker> checker)
{
  m_checkers.push_back(std::move(checker));
}
 
bool
Rule::match(uint32_t pktType, const Name& pktName, const shared_ptr<ValidationState>& state) const
{
  NDN_LOG_TRACE("Trying to match " << pktName);
  if (pktType != m_pktType) {
    NDN_THROW(Error("Invalid packet type supplied (" + to_string(pktType) +
                    " != " + to_string(m_pktType) + ")"));
  }
 
  if (m_filters.empty()) {
    return true;
  }
 
  bool retval = false;
  for (const auto& filter : m_filters) {
    retval |= filter->match(pktType, pktName, state);
    if (retval) {
      break;
    }
  }
  return retval;
}
 
bool
Rule::check(uint32_t pktType, tlv::SignatureTypeValue sigType, const Name& pktName, const Name& klName,
            const shared_ptr<ValidationState>& state) const
{
  NDN_LOG_TRACE("Trying to check " << pktName << " with KeyLocator " << klName);
 
  if (pktType != m_pktType) {
    NDN_THROW(Error("Invalid packet type supplied (" + to_string(pktType) +
                    " != " + to_string(m_pktType) + ")"));
  }
 
  std::vector<Checker::Result> checkerResults;
  checkerResults.reserve(m_checkers.size());
  for (const auto& checker : m_checkers) {
    auto result = checker->check(pktType, sigType, pktName, klName, *state);
    if (result) {
      return true;
    }
    checkerResults.push_back(std::move(result));
  }
 
  std::ostringstream err;
  err << "Packet " << pktName << " (KeyLocator=" << klName << ") cannot pass any checker.";
  for (size_t i = 0; i < checkerResults.size(); ++i) {
    err << "\nChecker " << i << ": " << checkerResults[i].getErrorMessage();
  }
  state->fail({ValidationError::POLICY_ERROR, err.str()});
  return false;
}
 
unique_ptr<Rule>
Rule::create(const ConfigSection& configSection, const std::string& configFilename)
{
  auto propertyIt = configSection.begin();
 
  // Get rule.id
  if (propertyIt == configSection.end() || !boost::iequals(propertyIt->first, "id")) {
    NDN_THROW(Error("Expecting <rule.id>"));
  }
 
  std::string ruleId = propertyIt->second.data();
  propertyIt++;
 
  // Get rule.for
  if (propertyIt == configSection.end() || !boost::iequals(propertyIt->first, "for")) {
    NDN_THROW(Error("Expecting <rule.for> in rule: " + ruleId));
  }
 
  std::string usage = propertyIt->second.data();
  propertyIt++;
 
  bool isForData = false;
  if (boost::iequals(usage, "data")) {
    isForData = true;
  }
  else if (boost::iequals(usage, "interest")) {
    isForData = false;
  }
  else {
    NDN_THROW(Error("Unrecognized <rule.for>: " + usage + " in rule: " + ruleId));
  }
 
  auto rule = make_unique<Rule>(ruleId, isForData ? tlv::Data : tlv::Interest);
 
  // Get rule.filter(s)
  for (; propertyIt != configSection.end(); propertyIt++) {
    if (!boost::iequals(propertyIt->first, "filter")) {
      if (boost::iequals(propertyIt->first, "checker")) {
        break;
      }
      NDN_THROW(Error("Expecting <rule.filter> in rule: " + ruleId));
    }
 
    rule->addFilter(Filter::create(propertyIt->second, configFilename));
  }
 
  // Get rule.checker(s)
  bool hasCheckers = false;
  for (; propertyIt != configSection.end(); propertyIt++) {
    if (!boost::iequals(propertyIt->first, "checker")) {
      NDN_THROW(Error("Expecting <rule.checker> in rule: " + ruleId));
    }
 
    rule->addChecker(Checker::create(propertyIt->second, configFilename));
    hasCheckers = true;
  }
 
  if (propertyIt != configSection.end()) {
    NDN_THROW(Error("Expecting end of <rule>: " + ruleId));
  }
 
  if (!hasCheckers) {
    NDN_THROW(Error("No <rule.checker> is specified in rule: " + ruleId));
  }
 
  return rule;
}
 
} // namespace validator_config
} // inline namespace v2
} // namespace security
} // namespace ndn