update name assignment part
Change-Id: I9655448b2d2ed927e36e55ac49357afa0470e507
diff --git a/src/name-assignments/assignment-funcs.cpp b/src/name-assignments/assignment-funcs.cpp
index 6e7f008..501c510 100644
--- a/src/name-assignments/assignment-funcs.cpp
+++ b/src/name-assignments/assignment-funcs.cpp
@@ -24,25 +24,24 @@
namespace ndn {
namespace ndncert {
-NameAssignmentFuncFactory::NameAssignmentFuncFactory(const std::string& factoryType)
+NameAssignmentFuncFactory::NameAssignmentFuncFactory(const std::string& factoryType, const std::string& format)
: FACTORY_TYPE(factoryType)
{
-}
-
-bool
-NameAssignmentFuncFactory::isChallengeSupported(const std::string& challengeType)
-{
- FuncFactoryFactory& factory = getFactory();
- auto i = factory.find(challengeType);
- return i != factory.end();
+ auto s = format;
+ size_t pos = 0;
+ while ((pos = s.find("/")) != std::string::npos) {
+ m_nameFormat.push_back(s.substr(0, pos));
+ s.erase(0, pos + 1);
+ }
+ m_nameFormat.push_back(s);
}
unique_ptr<NameAssignmentFuncFactory>
-NameAssignmentFuncFactory::createNameAssignmentFuncFactory(const std::string& challengeType)
+NameAssignmentFuncFactory::createNameAssignmentFuncFactory(const std::string& challengeType, const std::string& format)
{
FuncFactoryFactory& factory = getFactory();
auto i = factory.find(challengeType);
- return i == factory.end() ? nullptr : i->second();
+ return i == factory.end() ? nullptr : i->second(format);
}
NameAssignmentFuncFactory::FuncFactoryFactory&
diff --git a/src/name-assignments/assignment-funcs.hpp b/src/name-assignments/assignment-funcs.hpp
index bef3de1..b8c2dd1 100644
--- a/src/name-assignments/assignment-funcs.hpp
+++ b/src/name-assignments/assignment-funcs.hpp
@@ -21,16 +21,26 @@
#ifndef NDNCERT_ASSIGNMENT_FUNCS_HPP
#define NDNCERT_ASSIGNMENT_FUNCS_HPP
-#include <configuration.hpp>
-#include "ca-state.hpp"
+#include "../ca-state.hpp"
namespace ndn {
namespace ndncert {
+/**
+ * @brief The name assignment function provided by the CA operator to generate available
+ * namecomponents.
+ * The function does not guarantee that all the returned names are available. Therefore the
+ * CA should further check the availability of each returned name and remove unavailable results.
+ *
+ * @p vector, input, a list of parameter key-value pair used for name assignment.
+ * @return a vector containing the possible namespaces derived from the parameters.
+ */
+using NameAssignmentFunc = function<std::vector<PartialName>(const std::vector<std::tuple<std::string, std::string>>&)>;
+
class NameAssignmentFuncFactory : noncopyable {
public:
explicit
- NameAssignmentFuncFactory(const std::string& factoryType);
+ NameAssignmentFuncFactory(const std::string& factoryType, const std::string& format = "");
virtual ~NameAssignmentFuncFactory() = default;
@@ -40,23 +50,21 @@
{
FuncFactoryFactory& factory = getFactory();
BOOST_ASSERT(factory.count(typeName) == 0);
- factory[typeName] = [] { return make_unique<ChallengeType>(); };
+ factory[typeName] = [](const std::string& format) { return make_unique<ChallengeType>(format); };
}
- static bool
- isChallengeSupported(const std::string& challengeType);
-
static unique_ptr<NameAssignmentFuncFactory>
- createNameAssignmentFuncFactory(const std::string& challengeType);
+ createNameAssignmentFuncFactory(const std::string& challengeType, const std::string& format = "");
- virtual NameAssignmentFunc
- getFunction(const std::string& factoryParam) = 0;
+ virtual std::vector<PartialName>
+ assignName(const std::vector<std::tuple<std::string, std::string>>& params) = 0;
public:
const std::string FACTORY_TYPE;
+ std::vector<std::string> m_nameFormat;
private:
- typedef function<unique_ptr<NameAssignmentFuncFactory>()> FactoryCreateFunc;
+ typedef function<unique_ptr<NameAssignmentFuncFactory>(const std::string&)> FactoryCreateFunc;
typedef std::map<std::string, FactoryCreateFunc> FuncFactoryFactory;
static FuncFactoryFactory&
diff --git a/src/name-assignments/assignment-hash.cpp b/src/name-assignments/assignment-hash.cpp
index ebcf6d0..c71b369 100644
--- a/src/name-assignments/assignment-hash.cpp
+++ b/src/name-assignments/assignment-hash.cpp
@@ -8,56 +8,32 @@
namespace ndn {
namespace ndncert {
-_LOG_INIT(ndncert.assignment.hash);
-
NDNCERT_REGISTER_FUNCFACTORY(AssignmentHash, "hash");
-AssignmentHash::AssignmentHash()
- : NameAssignmentFuncFactory("hash")
+AssignmentHash::AssignmentHash(const std::string& format)
+ : NameAssignmentFuncFactory("hash", format)
+{}
+
+std::vector<PartialName>
+AssignmentHash::assignName(const std::vector<std::tuple<std::string, std::string>>& params)
{
-}
-
-NameAssignmentFunc
-AssignmentHash::getFunction(const std::string &factoryParam) {
- std::list<std::string> paramList;
- size_t index = 0, startIndex = 0;
- while ((index = factoryParam.find("/", startIndex)) != std::string::npos) {
- auto component = factoryParam.substr(startIndex, index - startIndex);
- if (!component.empty()) {
- paramList.push_back(component);
- }
- startIndex = index + 1;
+ std::vector<PartialName> resultList;
+ Name result;
+ for (const auto& item : m_nameFormat) {
+ auto it = std::find_if(params.begin(), params.end(),
+ [&](const std::tuple<std::string, std::string>& e) { return std::get<0>(e) == item; });
+ if (it != params.end()) {
+ util::Sha256 digest;
+ digest << std::get<1>(*it);
+ result.append(digest.toString());
}
- if (startIndex != factoryParam.size()) {
- paramList.push_back(factoryParam.substr(startIndex));
+ else {
+ return resultList;
}
- return [paramList](const std::vector<std::tuple<std::string, std::string>> params){
- if (params.size() > paramList.size() * 8) { // might be attack
- BOOST_THROW_EXCEPTION(std::runtime_error("Too many extra parameters given"));
- }
- std::map<std::string, std::string> paramMap;
- for (const auto& param : params) {
- paramMap[std::get<0>(param)] = std::get<1>(param);
- }
-
- //construct name
- PartialName name;
- for (const auto& field : paramList) {
- auto it = paramMap.find(field);
- if (it == paramMap.end()) {
- return std::vector<PartialName>();
- } else {
- name.append(it->second);
- }
- }
- std::vector<PartialName> nameList;
- util::Sha256 digest;
- digest << name.wireEncode();
- nameList.emplace_back(digest.toString());
-
- return nameList;
- };
+ }
+ resultList.push_back(std::move(result));
+ return resultList;
}
-}
-}
+} // namespace ndncert
+} // namespace ndn
diff --git a/src/name-assignments/assignment-hash.hpp b/src/name-assignments/assignment-hash.hpp
index 8ff253f..9054bb7 100644
--- a/src/name-assignments/assignment-hash.hpp
+++ b/src/name-assignments/assignment-hash.hpp
@@ -13,11 +13,12 @@
/**
* assign names base on client probe parameter
*/
-class AssignmentHash: public NameAssignmentFuncFactory{
+class AssignmentHash: public NameAssignmentFuncFactory {
public:
- AssignmentHash();
+ AssignmentHash(const std::string& format = "");
- NameAssignmentFunc getFunction(const std::string &factoryParam) override;
+ std::vector<PartialName>
+ assignName(const std::vector<std::tuple<std::string, std::string>>& params) override;
};
}
diff --git a/src/name-assignments/assignment-or.cpp b/src/name-assignments/assignment-or.cpp
deleted file mode 100644
index 78cfc3e..0000000
--- a/src/name-assignments/assignment-or.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// Created by Tyler on 10/6/20.
-//
-
-#include <iosfwd>
-#include "assignment-or.hpp"
-
-namespace ndn {
-namespace ndncert {
-
-NDNCERT_REGISTER_FUNCFACTORY(AssignmentOr, "or");
-
-AssignmentOr::AssignmentOr()
- : NameAssignmentFuncFactory("or")
-{
-}
-
-NameAssignmentFunc
-AssignmentOr::getFunction(std::list<NameAssignmentFunc> funcs){
- if (funcs.size() == 1) return *funcs.begin();
- return [funcs](const std::vector<std::tuple<std::string, std::string>> params){
- std::vector<PartialName> nameList;
- for (const auto& func : funcs) {
- auto result = func(params);
- nameList.insert(nameList.end(), result.begin(), result.end());
- }
-
- return nameList;
- };
-}
-
-NameAssignmentFunc
-AssignmentOr::getFunction(const std::string &factoryParam) {
- std::list<NameAssignmentFunc> paramList;
- std::stringstream ss;
- ss << factoryParam;
- JsonSection section;
- try {
- boost::property_tree::read_json(ss, section);
- }
- catch (const std::exception& error) {
- BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Failed to parse configuration for name assignment function or, ") + error.what()));
- }
- if (section.begin() == section.end()) {
- BOOST_THROW_EXCEPTION(std::runtime_error("No JSON configuration found for name assignment function"));
- }
- for (const auto& item: section) {
- auto factory = NameAssignmentFuncFactory::createNameAssignmentFuncFactory(item.first);
- if (!factory) {
- BOOST_THROW_EXCEPTION(std::runtime_error("Invalid assignment factory type"));
- }
- try {
- paramList.push_back(factory->getFunction(item.second.data()));
- } catch (const std::exception& e) {
- BOOST_THROW_EXCEPTION(std::runtime_error("Error on creating function"));
- }
- }
-
- return getFunction(paramList);
-}
-
-}
-}
diff --git a/src/name-assignments/assignment-or.hpp b/src/name-assignments/assignment-or.hpp
deleted file mode 100644
index 8d056f3..0000000
--- a/src/name-assignments/assignment-or.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Created by Tyler on 10/6/20.
-//
-
-#ifndef NDNCERT_ASSIGNMENT_OR_HPP
-#define NDNCERT_ASSIGNMENT_OR_HPP
-
-#include "assignment-funcs.hpp"
-
-namespace ndn {
-namespace ndncert {
-
-/**
- * assign names base on client probe parameter
- */
-class AssignmentOr: public NameAssignmentFuncFactory{
-public:
- AssignmentOr();
-
- NameAssignmentFunc getFunction(std::list<NameAssignmentFunc> funcs);
-
- NameAssignmentFunc getFunction(const std::string &factoryParam) override;
-
-};
-}
-}
-
-
-
-#endif //NDNCERT_ASSIGNMENT_OR_HPP
diff --git a/src/name-assignments/assignment-param.cpp b/src/name-assignments/assignment-param.cpp
index e32665e..56da436 100644
--- a/src/name-assignments/assignment-param.cpp
+++ b/src/name-assignments/assignment-param.cpp
@@ -7,56 +7,30 @@
namespace ndn {
namespace ndncert {
-_LOG_INIT(ndncert.assignment.param);
-
NDNCERT_REGISTER_FUNCFACTORY(AssignmentParam, "param");
-AssignmentParam::AssignmentParam()
- : NameAssignmentFuncFactory("param")
+AssignmentParam::AssignmentParam(const std::string& format)
+ : NameAssignmentFuncFactory("param", format)
+{}
+
+std::vector<PartialName>
+AssignmentParam::assignName(const std::vector<std::tuple<std::string, std::string>>& params)
{
-}
-
-NameAssignmentFunc
-AssignmentParam::getFunction(const std::string &factoryParam) {
- std::list<std::string> paramList;
- size_t index = 0, startIndex = 0;
- while ((index = factoryParam.find("/", startIndex)) != std::string::npos) {
- auto component = factoryParam.substr(startIndex, index - startIndex);
- if (!component.empty()) {
- paramList.push_back(component);
- }
- startIndex = index + 1;
+ std::vector<PartialName> resultList;
+ Name result;
+ for (const auto& item : m_nameFormat) {
+ auto it = std::find_if(params.begin(), params.end(),
+ [&](const std::tuple<std::string, std::string>& e) { return std::get<0>(e) == item; });
+ if (it != params.end()) {
+ result.append(std::get<1>(*it));
}
- if (startIndex != factoryParam.size()) {
- paramList.push_back(factoryParam.substr(startIndex));
+ else {
+ return resultList;
}
- return [paramList](const std::vector<std::tuple<std::string, std::string>> params){
- if (params.size() > paramList.size() * 8) { // might be attack
- BOOST_THROW_EXCEPTION(std::runtime_error("Too many extra parameters given"));
- }
- std::map<std::string, std::string> paramMap;
- for (const auto& param : params) {
- paramMap[std::get<0>(param)] = std::get<1>(param);
- if (std::get<1>(param).size() == 0) { // empty parameter!
- return std::vector<PartialName>();
- }
- }
-
- //construct name
- PartialName name;
- for (const auto& field : paramList) {
- auto it = paramMap.find(field);
- if (it == paramMap.end()) {
- return std::vector<PartialName>();
- } else {
- name.append(it->second);
- }
- }
- std::vector<PartialName> nameList;
- nameList.push_back(name);
- return nameList;
- };
+ }
+ resultList.push_back(std::move(result));
+ return resultList;
}
-}
-}
+} // namespace ndncert
+} // namespace ndn
diff --git a/src/name-assignments/assignment-param.hpp b/src/name-assignments/assignment-param.hpp
index c80f850..9633a57 100644
--- a/src/name-assignments/assignment-param.hpp
+++ b/src/name-assignments/assignment-param.hpp
@@ -15,10 +15,10 @@
*/
class AssignmentParam: public NameAssignmentFuncFactory{
public:
- AssignmentParam();
+ AssignmentParam(const std::string& format = "");
- NameAssignmentFunc getFunction(const std::string &factoryParam) override;
-
+ std::vector<PartialName>
+ assignName(const std::vector<std::tuple<std::string, std::string>>& params) override;
};
}
}
diff --git a/src/name-assignments/assignment-random.cpp b/src/name-assignments/assignment-random.cpp
index 9ebf45f..88e9a91 100644
--- a/src/name-assignments/assignment-random.cpp
+++ b/src/name-assignments/assignment-random.cpp
@@ -8,22 +8,18 @@
namespace ndn {
namespace ndncert {
-_LOG_INIT(ndncert.assignment.random);
-
NDNCERT_REGISTER_FUNCFACTORY(AssignmentRandom, "random");
-AssignmentRandom::AssignmentRandom()
- : NameAssignmentFuncFactory("random")
-{
-}
+AssignmentRandom::AssignmentRandom(const std::string& format)
+ : NameAssignmentFuncFactory("random", format)
+{}
-NameAssignmentFunc
-AssignmentRandom::getFunction(const std::string &factoryParam) {
- return [](const std::vector<std::tuple<std::string, std::string>>){
- std::vector<PartialName> names;
- names.emplace_back(to_string(random::generateSecureWord64()));
- return names;
- };
+std::vector<PartialName>
+AssignmentRandom::assignName(const std::vector<std::tuple<std::string, std::string>>& params)
+{
+ std::vector<PartialName> resultList;
+ resultList.emplace_back(to_string(random::generateSecureWord64()));
+ return resultList;
}
}
diff --git a/src/name-assignments/assignment-random.hpp b/src/name-assignments/assignment-random.hpp
index 64de3df..c35c143 100644
--- a/src/name-assignments/assignment-random.hpp
+++ b/src/name-assignments/assignment-random.hpp
@@ -13,12 +13,12 @@
/**
* assign names base on client probe parameter
*/
-class AssignmentRandom: public NameAssignmentFuncFactory{
+class AssignmentRandom: public NameAssignmentFuncFactory {
public:
- AssignmentRandom();
+ AssignmentRandom(const std::string& format = "");
- NameAssignmentFunc getFunction(const std::string &factoryParam) override;
-
+ std::vector<PartialName>
+ assignName(const std::vector<std::tuple<std::string, std::string>>& params) override;
};
}