bool
Interest::matchesName(const Name& name) const
{
if (name.size() < m_name.size())
return false;
if (!m_name.isPrefixOf(name))
return false;
if (getMinSuffixComponents() >= 0 &&
// name must include implicit digest
!(name.size() - m_name.size() >= static_cast<size_t>(getMinSuffixComponents())))
return false;
if (getMaxSuffixComponents() >= 0 &&
// name must include implicit digest
!(name.size() - m_name.size() <= static_cast<size_t>(getMaxSuffixComponents())))
return false;
if (!getExclude().empty() &&
name.size() > m_name.size() &&
getExclude().isExcluded(name[m_name.size()]))
return false;
return true;
}
int IpsiusService::NObjBoardFilter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
typedef Domain::NamedObject QMocSuperClass;
_id = QMocSuperClass::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: Include((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 1: Exclude((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 2: Clear(); break;
default: ;
}
_id -= 3;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = getExclude(); break;
case 1: *reinterpret_cast< QString*>(_v) = getInclude(); break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
bool
Interest::matchesData(const Data& data) const
{
size_t interestNameLength = m_name.size();
const Name& dataName = data.getName();
size_t fullNameLength = dataName.size() + 1;
// check MinSuffixComponents
bool hasMinSuffixComponents = getMinSuffixComponents() >= 0;
size_t minSuffixComponents = hasMinSuffixComponents ?
static_cast<size_t>(getMinSuffixComponents()) : 0;
if (!(interestNameLength + minSuffixComponents <= fullNameLength))
return false;
// check MaxSuffixComponents
bool hasMaxSuffixComponents = getMaxSuffixComponents() >= 0;
if (hasMaxSuffixComponents &&
!(interestNameLength + getMaxSuffixComponents() >= fullNameLength))
return false;
// check prefix
if (interestNameLength == fullNameLength) {
if (m_name.get(-1).isImplicitSha256Digest()) {
if (m_name != data.getFullName())
return false;
}
else {
// Interest Name is same length as Data full Name, but last component isn't digest
// so there's no possibility of matching
return false;
}
}
else {
// Interest Name is a strict prefix of Data full Name
if (!m_name.isPrefixOf(dataName))
return false;
}
// check Exclude
// Exclude won't be violated if Interest Name is same as Data full Name
if (!getExclude().empty() && fullNameLength > interestNameLength) {
if (interestNameLength == fullNameLength - 1) {
// component to exclude is the digest
if (getExclude().isExcluded(data.getFullName().get(interestNameLength)))
return false;
// There's opportunity to inspect the Exclude filter and determine whether
// the digest would make a difference.
// eg. "<NameComponent>AA</NameComponent><Any/>" doesn't exclude any digest -
// fullName not needed;
// "<Any/><NameComponent>AA</NameComponent>" and
// "<Any/><ImplicitSha256DigestComponent>ffffffffffffffffffffffffffffffff
// </ImplicitSha256DigestComponent>"
// excludes all digests - fullName not needed;
// "<Any/><ImplicitSha256DigestComponent>80000000000000000000000000000000
// </ImplicitSha256DigestComponent>"
// excludes some digests - fullName required
// But Interests that contain the exact Data Name before digest and also
// contain Exclude filter is too rare to optimize for, so we request
// fullName no mater what's in the Exclude filter.
}
else {
// component to exclude is not the digest
if (getExclude().isExcluded(dataName.get(interestNameLength)))
return false;
}
}
// check PublisherPublicKeyLocator
const KeyLocator& publisherPublicKeyLocator = this->getPublisherPublicKeyLocator();
if (!publisherPublicKeyLocator.empty()) {
const Signature& signature = data.getSignature();
const Block& signatureInfo = signature.getInfo();
Block::element_const_iterator it = signatureInfo.find(tlv::KeyLocator);
if (it == signatureInfo.elements_end()) {
return false;
}
if (publisherPublicKeyLocator.wireEncode() != *it) {
return false;
}
}
return true;
}
