void EMailConvergenceLayer::queue(const dtn::core::Node &node,
const dtn::net::BundleTransfer &job)
{
// Check if node supports email convergence layer
const std::list<dtn::core::Node::URI> uri_list = node.get(dtn::core::Node::CONN_EMAIL);
if (uri_list.empty())
{
dtn::net::TransferAbortedEvent::raise(node.getEID(), job.getBundle(),
dtn::net::TransferAbortedEvent::REASON_UNDEFINED);
return;
}
// Get recipient
std::string recipient = dtn::utils::Utils::tokenize("//", node.getEID().getString())[1];
// Create new Task
EMailSmtpService::Task *t = new EMailSmtpService::Task(node, job, recipient);
// Submit Task
if(_config.getSmtpSubmitInterval() <= 0)
{
_smtp.submitNow(t);
}else{
_smtp.queueTask(t);
}
IBRCOMMON_LOGGER(info) << "EMail Convergence Layer: Bundle " << t->getJob().getBundle().toString() << " stored in submit queue" << IBRCOMMON_LOGGER_ENDL;
}
bool dtn::dht::DHTNameService::isNeighbourAnnouncable(
const dtn::core::Node &node) {
if (!_config.isNeighbourAnnouncementEnabled())
return false;
// If forwarding of bundles is disabled, do not announce the neighbors to
// prevent receiving bundles for neighbor EIDs, which would not be forwarded
if (!daemon::Configuration::getInstance().getNetwork().doForwarding()) {
return false;
}
// get the merged node object
const dtn::core::Node n = dtn::core::BundleCore::getInstance().getConnectionManager().getNeighbor(
node.getEID());
// Ignore all none discovered and none static nodes
// They could only be discovered by the DHT,
// so they are not really close neighbours and could be found directly in the DHT.
// This prevents the node to be announced by all neighbours, how found this node
std::set<dtn::core::Node::Type> types = n.getTypes();
if (types.find(dtn::core::Node::NODE_DISCOVERED) == types.end()
&& (types.find(dtn::core::Node::NODE_STATIC_GLOBAL) == types.end())) {
return false;
}
// Proof, if the neighbour has told us, that he don't want to be published on the DHT
std::list<dtn::core::Node::Attribute> services = n.get("dhtns");
if (!services.empty()) {
for (std::list<dtn::core::Node::Attribute>::const_iterator service =
services.begin(); service != services.end(); ++service) {
bool proxy = true;
std::vector < string > parameters = dtn::utils::Utils::tokenize(
";", (*service).value);
std::vector<string>::const_iterator param_iter = parameters.begin();
while (param_iter != parameters.end()) {
std::vector < string > p = dtn::utils::Utils::tokenize("=",
(*param_iter));
if (p[0].compare("proxy") == 0) {
std::stringstream proxy_stream;
proxy_stream << p[1];
proxy_stream >> proxy;
}
++param_iter;
}
if (!proxy)
return false;
}
}
/**
* Reads the own EID and publishes all the available Convergence Layer in the DHT
*/
void dtn::dht::DHTNameService::announce(const dtn::core::Node &n,
enum dtn_dht_lookup_type type) {
if (this->_announced) {
std::string eid_ = n.getEID().getNode().getString();
ibrcommon::MutexLock l(this->_libmutex);
int rc = dtn_dht_announce(&_context, eid_.c_str(), eid_.size(), type);
if (rc > 0) {
IBRCOMMON_LOGGER_TAG("DHTNameService", info) << "DHT Announcing: " << eid_
<< IBRCOMMON_LOGGER_ENDL;
}
}
}
