void SQLiteBundleSet::add(const dtn::data::MetaBundle &bundle) throw ()
{
try {
// insert bundle id into database
SQLiteDatabase::Statement st(_sqldb._database, SQLiteDatabase::_sql_queries[SQLiteDatabase::BUNDLE_SET_ADD]);
sqlite3_bind_int64(*st, 1, _set_id);
sqlite3_bind_text(*st, 2, bundle.source.getString().c_str(), static_cast<int>(bundle.source.getString().length()), SQLITE_TRANSIENT);
sqlite3_bind_int64(*st, 3, bundle.timestamp.get<uint64_t>());
sqlite3_bind_int64(*st, 4, bundle.sequencenumber.get<uint64_t>());
if (bundle.isFragment()) {
sqlite3_bind_int64(*st, 5, bundle.fragmentoffset.get<uint64_t>());
sqlite3_bind_int64(*st, 6, bundle.getPayloadLength());
} else {
sqlite3_bind_int64(*st, 5, -1);
sqlite3_bind_int64(*st, 6, -1);
}
sqlite3_bind_int64(*st, 7, bundle.expiretime.get<uint64_t>());
st.step();
// update expiretime, if necessary
new_expire_time(bundle.expiretime);
// add bundle to the bloomfilter
bundle.addTo(_bf);
} catch (const SQLiteDatabase::SQLiteQueryException&) {
// error
}
}
void NativeSession::receive() throw (NativeSessionException)
{
Registration ® = _registration;
try {
try {
const dtn::data::MetaBundle id = reg.receiveMetaBundle();
if (id.procflags & dtn::data::PrimaryBlock::APPDATA_IS_ADMRECORD) {
// transform custody signals & status reports into notifies
fireNotificationAdministrativeRecord(id);
// announce the delivery of this bundle
reg.delivered(id);
} else {
IBRCOMMON_LOGGER_DEBUG_TAG(NativeSession::TAG, 20) << "fire notification for new bundle " << id.toString() << IBRCOMMON_LOGGER_ENDL;
// put the bundle into the API queue
_bundle_queue.push(id);
// notify the client about the new bundle
fireNotificationBundle(id);
}
} catch (const dtn::storage::NoBundleFoundException&) {
IBRCOMMON_LOGGER_DEBUG_TAG(NativeSession::TAG, 25) << "no more bundles found - wait until we are notified" << IBRCOMMON_LOGGER_ENDL;
reg.wait_for_bundle();
}
} catch (const ibrcommon::QueueUnblockedException &ex) {
throw NativeSessionException(std::string("loop aborted - ") + ex.what());
} catch (const std::exception &ex) {
throw NativeSessionException(std::string("loop aborted - ") + ex.what());
}
}
virtual bool shouldAdd(const dtn::data::MetaBundle &meta) const throw (dtn::storage::BundleSelectorException)
{
// filter fragments if requested
if (meta.isFragment() && _fragment_filter)
{
return false;
}
if (_endpoints.find(meta.destination) == _endpoints.end())
{
return false;
}
// filter own bundles
if (!_loopback)
{
if (_endpoints.find(meta.source) != _endpoints.end())
{
return false;
}
}
IBRCOMMON_LOGGER_DEBUG_TAG(Registration::TAG, 30) << "search bundle in the list of delivered bundles: " << meta.toString() << IBRCOMMON_LOGGER_ENDL;
if (_queue.has(meta))
{
return false;
}
return true;
};
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 MemoryBundleSet::add(const dtn::data::MetaBundle &bundle) throw ()
{
// insert bundle id to the private list
pair<bundle_set::iterator,bool> ret = _bundles.insert(bundle);
BundleSetImpl::ExpiringBundle exb(*ret.first);
_expire.insert(exb);
// add bundle to the bloomfilter
bundle.addTo(_bf);
}
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());
}
}
}
/**
* Transfer one bundle to another node.
* @param destination The EID of the other node.
* @param id The ID of the bundle to transfer. This bundle must be stored in the storage.
*/
void RoutingExtension::transferTo(const dtn::data::EID &destination, const dtn::data::MetaBundle &meta)
{
// acquire the transfer of this bundle, could throw already in transit or no resource left exception
{
// lock the list of neighbors
ibrcommon::MutexLock l((**this).getNeighborDB());
// get the neighbor entry for the next hop
NeighborDatabase::NeighborEntry &entry = (**this).getNeighborDB().get(destination, true);
// acquire the transfer, could throw already in transit or no resource left exception
entry.acquireTransfer(meta);
}
try {
// create a new bundle transfer object
dtn::net::BundleTransfer transfer(destination, meta);
// transfer the bundle to the next hop
dtn::core::BundleCore::getInstance().getConnectionManager().queue(transfer);
IBRCOMMON_LOGGER_DEBUG_TAG(RoutingExtension::TAG, 20) << "bundle " << meta.toString() << " queued for " << destination.getString() << IBRCOMMON_LOGGER_ENDL;
} catch (const dtn::core::P2PDialupException&) {
// lock the list of neighbors
ibrcommon::MutexLock l((**this).getNeighborDB());
// get the neighbor entry for the next hop
NeighborDatabase::NeighborEntry &entry = (**this).getNeighborDB().get(destination);
// release the transfer
entry.releaseTransfer(meta);
// and abort the query
throw NeighborDatabase::NeighborNotAvailableException();
} catch (const ibrcommon::Exception &e) {
// ignore any other error
}
}
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);
}
void Registration::RegistrationQueue::put(const dtn::data::MetaBundle &bundle) throw ()
{
try {
_queue.push(bundle);
ibrcommon::MutexLock l(_lock);
_recv_bundles.add(bundle);
IBRCOMMON_LOGGER_DEBUG_TAG(Registration::TAG, 10) << "[RegistrationQueue] add bundle to list of delivered bundles: " << bundle.toString() << IBRCOMMON_LOGGER_ENDL;
} catch (const ibrcommon::Exception&) { }
}
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;
};
virtual bool shouldAdd(const dtn::data::MetaBundle &meta) const throw (dtn::storage::BundleSelectorException)
{
// select the bundle if it is in the filter
return meta.isIn(_filter);
};