void Registration::delivered(const dtn::data::MetaBundle &m) const
{
// raise bundle event
dtn::core::BundleEvent::raise(m, dtn::core::BUNDLE_DELIVERED);
if (m.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON))
{
dtn::core::BundlePurgeEvent::raise(m);
}
}
void EpidemicRoutingExtension::eventBundleQueued(const dtn::data::EID &peer, const dtn::data::MetaBundle &meta) throw ()
{
// ignore the bundle if the scope is limited to local delivery
if ((meta.hopcount <= 1) && (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON))) return;
// new bundles trigger a recheck for all neighbors
const std::set<dtn::core::Node> nl = dtn::core::BundleCore::getInstance().getConnectionManager().getNeighbors();
for (std::set<dtn::core::Node>::const_iterator iter = nl.begin(); iter != nl.end(); ++iter)
{
const dtn::core::Node &n = (*iter);
if (n.getEID() != peer)
{
// trigger all routing modules to search for bundles to forward
eventDataChanged(n.getEID());
}
}
}
void StatusReportGenerator::createStatusReport(const dtn::data::MetaBundle &b, StatusReportBlock::TYPE type, StatusReportBlock::REASON_CODE reason)
{
// create a new bundle
Bundle bundle;
// create a new statusreport block
StatusReportBlock &report = bundle.push_back<StatusReportBlock>();
bundle.set(dtn::data::PrimaryBlock::APPDATA_IS_ADMRECORD, true);
// get the flags and set the status flag
report._status |= type;
// set the reason code
report._reasoncode |= reason;
switch (type)
{
case StatusReportBlock::RECEIPT_OF_BUNDLE:
report._timeof_receipt.set();
break;
case StatusReportBlock::CUSTODY_ACCEPTANCE_OF_BUNDLE:
report._timeof_custodyaccept.set();
break;
case StatusReportBlock::FORWARDING_OF_BUNDLE:
report._timeof_forwarding.set();
break;
case StatusReportBlock::DELIVERY_OF_BUNDLE:
report._timeof_delivery.set();
break;
case StatusReportBlock::DELETION_OF_BUNDLE:
report._timeof_deletion.set();
break;
default:
break;
}
// set source and destination
bundle._source = dtn::core::BundleCore::local;
bundle.set(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON, true);
bundle._destination = b.reportto;
// set bundle parameter
if (b.get(Bundle::FRAGMENT))
{
report._fragment_offset = b.offset;
report._fragment_length = b.appdatalength;
report._admfield |= 1;
}
report._bundle_timestamp = b.timestamp;
report._bundle_sequence = b.sequencenumber;
report._source = b.source;
dtn::core::BundleGeneratedEvent::raise(bundle);
}
virtual bool addIfSelected(dtn::storage::BundleResult &result, const dtn::data::MetaBundle &meta) const throw (dtn::storage::BundleSelectorException)
{
// check Scope Control Block - do not forward bundles with hop limit == 0
if (meta.hopcount == 0)
{
return false;
}
// do not forward local bundles
if ((meta.destination.getNode() == dtn::core::BundleCore::local)
&& meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON)
)
{
return false;
}
// check Scope Control Block - do not forward non-group bundles with hop limit <= 1
if ((meta.hopcount <= 1) && (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON)))
{
return false;
}
// do not forward bundles addressed to this neighbor,
// because this is handled by neighbor routing extension
if (_entry.eid == meta.destination.getNode())
{
return false;
}
// request limits from neighbor database
try {
const RoutingLimitations &limits = _entry.getDataset<RoutingLimitations>();
if (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON))
{
// check if the peer accepts bundles for other nodes
if (limits.getLimit(RoutingLimitations::LIMIT_LOCAL_ONLY) > 0) return false;
}
else
{
// check if destination permits non-singleton bundles
if (limits.getLimit(RoutingLimitations::LIMIT_SINGLETON_ONLY) > 0) return false;
}
// check if the payload is too large for the neighbor
if ((limits.getLimit(RoutingLimitations::LIMIT_FOREIGN_BLOCKSIZE) > 0) &&
((size_t)limits.getLimit(RoutingLimitations::LIMIT_FOREIGN_BLOCKSIZE) < meta.getPayloadLength())) return false;
} catch (const NeighborDatabase::DatasetNotAvailableException&) { }
// if this is a singleton bundle ...
if (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON))
{
const dtn::core::Node n(meta.destination.getNode());
// do not forward the bundle if the final destination is available
if (_neighbors.find(n) != _neighbors.end())
{
return false;
}
}
// do not forward bundles already known by the destination
// throws BloomfilterNotAvailableException if no filter is available or it is expired
try {
if (_entry.has(meta, true))
{
return false;
}
} catch (const dtn::routing::NeighborDatabase::BloomfilterNotAvailableException&) {
throw dtn::storage::BundleSelectorException();
}
// update filter context
dtn::core::FilterContext context = _context;
context.setMetaBundle(meta);
// check bundle filter for each possible path
for (dtn::net::ConnectionManager::protocol_list::const_iterator it = _plist.begin(); it != _plist.end(); ++it)
{
const dtn::core::Node::Protocol &p = (*it);
// update context with current protocol
context.setProtocol(p);
// execute filtering
dtn::core::BundleFilter::ACTION ret = dtn::core::BundleCore::getInstance().evaluate(dtn::core::BundleFilter::ROUTING, context);
if (ret == dtn::core::BundleFilter::ACCEPT)
{
// put the selected bundle with targeted interface into the result-set
static_cast<RoutingResult&>(result).put(meta, p);
return true;
}
}
return false;
};
virtual bool addIfSelected(dtn::storage::BundleResult &result, const dtn::data::MetaBundle &meta) const throw (dtn::storage::BundleSelectorException)
{
// check Scope Control Block - do not forward bundles with hop limit == 0
if (meta.hopcount == 0)
{
return false;
}
// do not forward local bundles
if ((meta.destination.getNode() == dtn::core::BundleCore::local)
&& meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON)
)
{
return false;
}
// check Scope Control Block - do not forward non-group bundles with hop limit <= 1
if ((meta.hopcount <= 1) && (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON)))
{
return false;
}
// do not forward bundles addressed to this neighbor,
// because this is handled by neighbor routing extension
if (_entry.eid == meta.destination.getNode())
{
return false;
}
// if this is a singleton bundle ...
if (meta.get(dtn::data::PrimaryBlock::DESTINATION_IS_SINGLETON))
{
const dtn::core::Node n(meta.destination.getNode());
// do not forward the bundle if the final destination is available
if (_neighbors.find(n) != _neighbors.end())
{
return false;
}
}
// do not forward bundles already known by the destination
if (_entry.has(meta))
{
return false;
}
// update filter context
dtn::core::FilterContext context = _context;
context.setMetaBundle(meta);
// check bundle filter for each possible path
for (dtn::net::ConnectionManager::protocol_list::const_iterator it = _plist.begin(); it != _plist.end(); ++it)
{
const dtn::core::Node::Protocol &p = (*it);
// update context with current protocol
context.setProtocol(p);
// execute filtering
dtn::core::BundleFilter::ACTION ret = dtn::core::BundleCore::getInstance().evaluate(dtn::core::BundleFilter::ROUTING, context);
if (ret == dtn::core::BundleFilter::ACCEPT)
{
// put the selected bundle with targeted interface into the result-set
static_cast<RoutingResult&>(result).put(meta, p);
return true;
}
}
return false;
};