void RSASHA256Stream::reset()
{
EVP_MD_CTX_cleanup(&_ctx);
EVP_MD_CTX_init(&_ctx);
if (!_verify)
{
if (!EVP_SignInit_ex(&_ctx, EVP_sha256(), NULL))
{
IBRCOMMON_LOGGER_TAG("RSASHA256Stream", critical) << "failed to initialize the signature function" << IBRCOMMON_LOGGER_ENDL;
ERR_print_errors_fp(stderr);
}
}
else
{
if (!EVP_VerifyInit_ex(&_ctx, EVP_sha256(), NULL))
{
IBRCOMMON_LOGGER_TAG("RSASHA256Stream", critical) << "failed to initialize the verfication function" << IBRCOMMON_LOGGER_ENDL;
ERR_print_errors_fp(stderr);
}
}
_sign_valid = false;
}
void IPNDAgent::listen(const ibrcommon::vinterface &iface) throw ()
{
// create sockets for all addresses on the interface
std::list<ibrcommon::vaddress> addrs = iface.getAddresses();
for (std::list<ibrcommon::vaddress>::iterator iter = addrs.begin(); iter != addrs.end(); ++iter) {
ibrcommon::vaddress &addr = (*iter);
try {
// handle the addresses according to their family
switch (addr.family()) {
case AF_INET:
case AF_INET6:
{
ibrcommon::udpsocket *sock = new ibrcommon::udpsocket(addr);
if (_send_socket_state) sock->up();
_send_socket.add(sock, iface);
break;
}
default:
break;
}
} catch (const ibrcommon::vaddress::address_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
}
void IPNDAgent::send(const DiscoveryAnnouncement &a, const ibrcommon::vinterface &iface, const ibrcommon::vaddress &addr)
{
// serialize announcement
stringstream ss; ss << a;
const std::string data = ss.str();
ibrcommon::socketset fds = _send_socket.get(iface);
// send out discovery announcements on all bound sockets
// (hopefully only one per interface)
for (ibrcommon::socketset::const_iterator iter = fds.begin(); iter != fds.end(); ++iter)
{
try {
ibrcommon::udpsocket &sock = dynamic_cast<ibrcommon::udpsocket&>(**iter);
try {
// prevent broadcasting in the wrong address family
if (addr.family() != sock.get_family()) continue;
sock.sendto(data.c_str(), data.length(), 0, addr);
} catch (const ibrcommon::socket_exception &e) {
IBRCOMMON_LOGGER_DEBUG_TAG(IPNDAgent::TAG, 5) << "can not send message to " << addr.toString() << " via " << sock.get_address().toString() << "/" << iface.toString() << "; socket exception: " << e.what() << IBRCOMMON_LOGGER_ENDL;
} catch (const ibrcommon::vaddress::address_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
} catch (const std::bad_cast&) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << "Socket for sending isn't a udpsocket." << IBRCOMMON_LOGGER_ENDL;
}
}
}
void TCPConnection::eventConnectionUp(const dtn::streams::StreamContactHeader &header) throw ()
{
_peer = header;
// copy old attributes and urls to the new node object
Node n_old = _node;
_node = Node(header._localeid);
_node += n_old;
// check if the peer has the same EID
if (_node.getEID() == dtn::core::BundleCore::getInstance().local)
{
// abort the connection
shutdown();
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, warning) << "connection to local endpoint rejected" << IBRCOMMON_LOGGER_ENDL;
return;
}
_keepalive_timeout = header._keepalive * 1000;
try {
// initiate extended handshake (e.g. TLS)
initiateExtendedHandshake();
} catch (const ibrcommon::Exception &ex) {
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
// abort the connection
shutdown();
return;
}
// set the timer
timeval timeout;
timerclear(&timeout);
// set the incoming timer if set (> 0)
if (_peer._keepalive > 0)
{
timeout.tv_sec = header._keepalive * 2;
}
// change time-out
_socket_stream->setTimeout(timeout);
try {
// enable idle timeout
size_t _idle_timeout = dtn::daemon::Configuration::getInstance().getNetwork().getTCPIdleTimeout();
if (_idle_timeout > 0)
{
(*getProtocolStream()).enableIdleTimeout(_idle_timeout);
}
} catch (const ibrcommon::Exception&) {};
// raise up event
ConnectionEvent::raise(ConnectionEvent::CONNECTION_UP, _node);
}
void TCPConnection::initiateExtendedHandshake() throw (ibrcommon::Exception)
{
#ifdef WITH_TLS
/* if both nodes support TLS, activate it */
if (_peer._flags.getBit(dtn::streams::StreamContactHeader::REQUEST_TLS)
&& _flags.getBit(dtn::streams::StreamContactHeader::REQUEST_TLS))
{
try{
ibrcommon::TLSStream &tls = dynamic_cast<ibrcommon::TLSStream&>(*_sec_stream);
X509 *peer_cert = tls.activate();
// check the full EID first
const std::string cn = _peer.getEID().getString();
try {
try {
dtn::security::SecurityCertificateManager::validateSubject(peer_cert, cn);
} catch (const dtn::security::SecurityCertificateException &ex) {
// check using the hostname
std::string weak_cn = _peer.getEID().getHost();
// strip leading "//"
if (weak_cn.find_first_of("//") == 0) {
weak_cn = weak_cn.substr(2, weak_cn.length() - 2);
}
try {
dtn::security::SecurityCertificateManager::validateSubject(peer_cert, weak_cn);
} catch (const dtn::security::SecurityCertificateException &ex_weak) {
throw ex;
}
}
} catch (const dtn::security::SecurityCertificateException &ex) {
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
throw ibrcommon::TLSCertificateVerificationException(ex.what());
}
} catch (const std::exception&) {
if (dtn::daemon::Configuration::getInstance().getSecurity().TLSRequired()){
/* close the connection */
IBRCOMMON_LOGGER_DEBUG_TAG(TCPConnection::TAG, 20) << "TLS failed, closing the connection." << IBRCOMMON_LOGGER_ENDL;
throw;
} else {
IBRCOMMON_LOGGER_DEBUG_TAG(TCPConnection::TAG, 20) << "TLS failed, continuing unauthenticated." << IBRCOMMON_LOGGER_ENDL;
}
}
} else {
/* TLS not supported by both Nodes, check if its required */
if (dtn::daemon::Configuration::getInstance().getSecurity().TLSRequired()){
/* close the connection */
throw ibrcommon::TLSException("TLS not supported by peer.");
} else if(_flags & dtn::streams::StreamContactHeader::REQUEST_TLS){
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, notice) << "TLS not supported by peer. Continuing without TLS." << IBRCOMMON_LOGGER_ENDL;
}
/* else: this node does not support TLS, should have already printed a warning */
}
#endif
}
void IPNDAgent::join(const ibrcommon::vinterface &iface, const ibrcommon::vaddress &addr) throw ()
{
IBRCOMMON_LOGGER_DEBUG_TAG(TAG, 10) << "Join on " << iface.toString() << " (" << addr.toString() << ", family: " << addr.family() << ")" << IBRCOMMON_LOGGER_ENDL;
// only join IPv6 and IPv4 addresses
if ((addr.family() != AF_INET) && (addr.family() != AF_INET6)) return;
// do not join on loopback interfaces
if (addr.isLocal()) return;
// create a multicast socket and bind to given addr
ibrcommon::multicastsocket *msock = new ibrcommon::multicastsocket(addr);
// if we are in UP state
if (_state) {
try {
// bring up
msock->up();
// listen to multicast addresses
for (std::set<ibrcommon::vaddress>::const_iterator it_addr = _destinations.begin(); it_addr != _destinations.end(); ++it_addr)
{
if (msock->get_family() != it_addr->family())
continue;
try {
msock->join(*it_addr, iface);
} catch (const ibrcommon::socket_raw_error &e) {
if (e.error() == EADDRINUSE) {
// silent error
} else if (e.error() == 92) {
// silent error - protocol not available
} else {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << "Join to " << (*it_addr).toString() << " failed on " << iface.toString() << "; " << e.what() << IBRCOMMON_LOGGER_ENDL;
}
} catch (const ibrcommon::socket_exception &e) {
IBRCOMMON_LOGGER_DEBUG_TAG(IPNDAgent::TAG, 10) << "Join to " << (*it_addr).toString() << " failed on " << iface.toString() << "; " << e.what() << IBRCOMMON_LOGGER_ENDL;
}
}
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << "Join failed on " << iface.toString() << " (" << addr.toString() << ", family: " << addr.family() << ")" << "; " << ex.what() << IBRCOMMON_LOGGER_ENDL;
delete msock;
return;
}
}
// add multicast socket to _socket
_socket.add(msock, iface);
}
void SQLiteBundleSet::expire(const dtn::data::Timestamp timestamp) throw ()
{
// we can not expire bundles if we have no idea of time
if (timestamp == 0) return;
// do not expire if its not the time
if (_next_expiration > timestamp) return;
// look for expired bundles and announce them in the listener
if (_listener != NULL) {
try {
SQLiteDatabase::Statement st(_sqldb._database, SQLiteDatabase::_sql_queries[SQLiteDatabase::BUNDLE_SET_GET_EXPIRED]);
sqlite3_bind_int64(*st, 1, _set_id);
// set expiration timestamp
sqlite3_bind_int64(*st, 2, timestamp.get<uint64_t>());
while (st.step() == SQLITE_ROW)
{
dtn::data::BundleID id;
get_bundleid(st, id);
const dtn::data::MetaBundle bundle = dtn::data::MetaBundle::create(id);
// raise bundle expired event
_listener->eventBundleExpired(bundle);
}
} catch (const SQLiteDatabase::SQLiteQueryException &ex) {
IBRCOMMON_LOGGER_TAG(SQLiteDatabase::TAG, error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
// delete expired bundles
try {
SQLiteDatabase::Statement st(_sqldb._database, SQLiteDatabase::_sql_queries[SQLiteDatabase::BUNDLE_SET_EXPIRE]);
sqlite3_bind_int64(*st, 1, _set_id);
// set expiration timestamp
sqlite3_bind_int64(*st, 2, timestamp.get<uint64_t>());
st.step();
} catch (const SQLiteDatabase::SQLiteQueryException &ex) {
IBRCOMMON_LOGGER_TAG(SQLiteDatabase::TAG, error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
// rebuild the bloom filter
rebuild_bloom_filter();
}
dtn::data::Bundle MemoryBundleStorage::get(const dtn::data::BundleID &id)
{
try {
ibrcommon::MutexLock l(_bundleslock);
for (bundle_list::const_iterator iter = _bundles.begin(); iter != _bundles.end(); ++iter)
{
const dtn::data::Bundle &bundle = (*iter);
if (id == bundle)
{
if (_faulty) {
throw dtn::SerializationFailedException("bundle get failed due to faulty setting");
}
return bundle;
}
}
} catch (const dtn::SerializationFailedException &ex) {
// bundle loading failed
IBRCOMMON_LOGGER_TAG(MemoryBundleStorage::TAG, error) << "Error while loading bundle data: " << ex.what() << IBRCOMMON_LOGGER_ENDL;
// the bundle is broken, delete it
remove(id);
throw BundleStorage::BundleLoadException();
}
throw NoBundleFoundException();
}
void Clock::setOffset(const struct timeval &tv)
{
if (!Clock::shouldModifyClock())
{
if (!Clock::_offset_init)
{
timerclear(&Clock::_offset);
Clock::_offset_init = true;
}
timeradd(&Clock::_offset, &tv, &Clock::_offset);
IBRCOMMON_LOGGER_TAG("Clock", info) << "new local offset: " << Clock::toDouble(_offset) << "s" << IBRCOMMON_LOGGER_ENDL;
}
else
{
struct timezone tz;
struct timeval now;
::gettimeofday(&now, &tz);
// adjust by the offset
timersub(&now, &tv, &now);
#ifndef __WIN32__
// set the local clock to the new timestamp
::settimeofday(&now, &tz);
#endif
}
}
bool PayloadConfidentialBlock::decryptPayload(dtn::data::Bundle& bundle, const unsigned char ephemeral_key[ibrcommon::AES128Stream::key_size_in_bytes], const uint32_t salt)
{
// TODO handle fragmentation
PayloadConfidentialBlock& pcb = bundle.find<PayloadConfidentialBlock>();
dtn::data::PayloadBlock& plb = bundle.find<dtn::data::PayloadBlock>();
// the array for the extracted iv
unsigned char iv[ibrcommon::AES128Stream::iv_len];
pcb._ciphersuite_params.get(SecurityBlock::initialization_vector, iv, ibrcommon::AES128Stream::iv_len);
// the array for the extracted tag
unsigned char tag[ibrcommon::AES128Stream::tag_len];
pcb._security_result.get(SecurityBlock::PCB_integrity_check_value, tag, ibrcommon::AES128Stream::tag_len);
// get the reference to the corresponding BLOB object
ibrcommon::BLOB::Reference blobref = plb.getBLOB();
// decrypt the payload and get the integrity signature (tag)
{
ibrcommon::BLOB::iostream stream = blobref.iostream();
ibrcommon::AES128Stream decrypt(ibrcommon::CipherStream::CIPHER_DECRYPT, *stream, ephemeral_key, salt, iv);
((ibrcommon::CipherStream&)decrypt).decrypt(*stream);
// get the decrypt tag
if (!decrypt.verify(tag))
{
IBRCOMMON_LOGGER_TAG("PayloadConfidentialBlock", error) << "integrity signature of the decrypted payload is invalid" << IBRCOMMON_LOGGER_ENDL;
return false;
}
}
return true;
}
void IPNDAgent::join(const ibrcommon::vinterface &iface) throw ()
{
// register as discovery handler for this interface
dtn::core::BundleCore::getInstance().getDiscoveryAgent().registerService(iface, this);
// do not create sockets for any interface
if (!iface.isAny()) {
// subscribe to NetLink events on our interfaces
ibrcommon::LinkManager::getInstance().addEventListener(iface, this);
/**
* create sockets for each address on the interface
*/
const std::list<ibrcommon::vaddress> addrs = iface.getAddresses();
for (std::list<ibrcommon::vaddress>::const_iterator it = addrs.begin(); it != addrs.end(); ++it)
{
const ibrcommon::vaddress addr = (*it);
// join to all multicast addresses on this interface
join(iface, addr);
}
}
/**
* subscribe to multicast address on this interface using the sockets bound to any address
*/
const ibrcommon::vinterface any_iface(ibrcommon::vinterface::ANY);
ibrcommon::socketset anysocks = _socket.get(any_iface);
for (ibrcommon::socketset::iterator it = anysocks.begin(); it != anysocks.end(); ++it)
{
ibrcommon::multicastsocket *msock = dynamic_cast<ibrcommon::multicastsocket*>(*it);
if (msock == NULL) continue;
for (std::set<ibrcommon::vaddress>::const_iterator addr_it = _destinations.begin(); addr_it != _destinations.end(); ++addr_it)
{
const ibrcommon::vaddress &addr = (*addr_it);
// join only if family matches
if (addr.family() != msock->get_family()) continue;
try {
msock->join(addr, iface);
IBRCOMMON_LOGGER_DEBUG_TAG(IPNDAgent::TAG, 10) << "Joined " << addr.toString() << " on " << iface.toString() << IBRCOMMON_LOGGER_ENDL;
} catch (const ibrcommon::socket_raw_error &e) {
if (e.error() == EADDRINUSE) {
// silent error
} else if (e.error() == 92) {
// silent error - protocol not available
} else {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << "Join to " << addr.toString() << " failed on " << iface.toString() << "; " << e.what() << IBRCOMMON_LOGGER_ENDL;
}
} catch (const ibrcommon::socket_exception &e) {
IBRCOMMON_LOGGER_DEBUG_TAG(IPNDAgent::TAG, 10) << "Join to " << addr.toString() << " failed on " << iface.toString() << "; " << e.what() << IBRCOMMON_LOGGER_ENDL;
}
}
}
}
void sighandler_func(int signal)
{
IBRCOMMON_LOGGER_TAG(TAG,notice) << "got signal " << signal << IBRCOMMON_LOGGER_ENDL;
switch (signal)
{
case SIGTERM:
case SIGINT:
{
//stop waiting and stop running, on SIGINT or SIGTERM
ibrcommon::MutexLock l(_wait_cond);
_running = false;
_wait_cond.signal(true);
break;
}
#ifndef __WIN32__
case SIGUSR1:
{
//stop waiting on SIGUSR1 -> "quickscan"
ibrcommon::MutexLock l(_wait_cond);
_wait_abort = true;
_wait_cond.signal(true);
break;
}
#endif
default:
break;
}
}
void EventDebugger::raiseEvent(const dtn::core::Event *evt) throw ()
{
// print event
if (evt->isLoggable())
{
IBRCOMMON_LOGGER_TAG(evt->getName(), notice) << evt->getMessage() << IBRCOMMON_LOGGER_ENDL;
}
}
void IPNDAgent::componentUp() throw ()
{
// routine checked for throw() on 15.02.2013
try {
// setup the receive socket
_recv_socket.up();
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
// join multicast groups
try {
ibrcommon::MutexLock l(_interface_lock);
for (std::set<ibrcommon::vinterface>::const_iterator it_iface = _interfaces.begin(); it_iface != _interfaces.end(); ++it_iface)
{
const ibrcommon::vinterface &iface = (*it_iface);
// subscribe to NetLink events on our interfaces
ibrcommon::LinkManager::getInstance().addEventListener(iface, this);
// listen on the interface
listen(iface);
// join to all multicast addresses on this interface
join_interface(iface);
}
} catch (std::bad_cast&) {
throw ibrcommon::socket_exception("no multicast socket found");
}
try {
// setup all send sockets
_send_socket.up();
// mark the send socket as up
_send_socket_state = true;
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
// listen on P2P dial-up events
dtn::core::EventDispatcher<dtn::net::P2PDialupEvent>::add(this);
}
void FileMonitor::componentUp() throw ()
{
// routine checked for throw() on 15.02.2013
try {
_socket.up();
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG("FileMonitor", error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
void TCPConnection::initialize() throw ()
{
// start the receiver for incoming bundles + handshake
try {
start();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
void IPNDAgent::leave_interface(const ibrcommon::vinterface &iface) throw ()
{
ibrcommon::multicastsocket &msock = dynamic_cast<ibrcommon::multicastsocket&>(**_recv_socket.getAll().begin());
for (std::set<ibrcommon::vaddress>::const_iterator it_addr = _destinations.begin(); it_addr != _destinations.end(); ++it_addr)
{
try {
msock.leave(*it_addr, iface);
} catch (const ibrcommon::socket_raw_error &e) {
if (e.error() != EADDRNOTAVAIL) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << "leave failed on " << iface.toString() << "; " << e.what() << IBRCOMMON_LOGGER_ENDL;
}
} catch (const ibrcommon::socket_exception &e) {
IBRCOMMON_LOGGER_DEBUG_TAG(IPNDAgent::TAG, 10) << "can not leave " << (*it_addr).toString() << " on " << iface.toString() << IBRCOMMON_LOGGER_ENDL;
} catch (const ibrcommon::Exception&) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, error) << "can not leave " << (*it_addr).toString() << " on " << iface.toString() << IBRCOMMON_LOGGER_ENDL;
}
}
}
void FloodRoutingExtension::componentDown() throw ()
{
try {
// stop the thread
stop();
join();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG(FloodRoutingExtension::TAG, error) << "componentDown failed: " << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
void Client::eventConnectionDown() throw ()
{
_inqueue.abort();
try {
_receiver.stop();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG("Client", error) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
void AbstractWorker::initialize(const std::string &uri, bool async)
{
_eid.setApplication(uri);
try {
if (async) _thread.start();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG("AbstractWorker", error) << "initialize failed: " << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
int FATFile::getFiles(std::list<FATFile> &files) const
{
try {
_reader.list(*this, files);
} catch (const FatImageReader::FatImageException &e) {
return e.getErrorCode();
}
IBRCOMMON_LOGGER_TAG(TAG,notice) << "getFile returning " << files.size() << " files" << IBRCOMMON_LOGGER_ENDL;
return 0;
}
void SecurityKeyManager::createRSA(const dtn::data::EID &ref, const int bits)
{
const ibrcommon::File privkey = getKeyFile(ref, SecurityKey::KEY_PRIVATE);
const ibrcommon::File pubkey = getKeyFile(ref, SecurityKey::KEY_PUBLIC);
RSA* rsa = RSA_new();
BIGNUM* e = BN_new();
BN_set_word(e, 65537);
RSA_generate_key_ex(rsa, bits, e, NULL);
BN_free(e);
e = NULL;
// write private key
int fd = ::open(privkey.getPath().c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600);
FILE * rsa_privkey_file = fdopen(fd, "w");
if (!rsa_privkey_file) {
IBRCOMMON_LOGGER_TAG(SecurityKeyManager::TAG, error) << "Failed to open " << privkey.getPath() << IBRCOMMON_LOGGER_ENDL;
RSA_free(rsa);
return;
}
PEM_write_RSAPrivateKey(rsa_privkey_file, rsa, NULL, NULL, 0, NULL, NULL);
fclose(rsa_privkey_file);
// write public key
FILE * rsa_pubkey_file = fopen(pubkey.getPath().c_str(), "w+");
if (!rsa_pubkey_file) {
IBRCOMMON_LOGGER_TAG(SecurityKeyManager::TAG, error) << "Failed to open " << privkey.getPath() << IBRCOMMON_LOGGER_ENDL;
RSA_free(rsa);
return;
}
PEM_write_RSA_PUBKEY(rsa_pubkey_file, rsa);
fclose(rsa_pubkey_file);
RSA_free(rsa);
// set trust-level to high
SecurityKey key = get(ref, SecurityKey::KEY_PUBLIC);
key.trustlevel = SecurityKey::HIGH;
store(key);
}
void FileMonitor::scan()
{
IBRCOMMON_LOGGER_DEBUG_TAG("FileMonitor", 5) << "scan for file changes" << IBRCOMMON_LOGGER_ENDL;
std::set<ibrcommon::File> watch_set;
for (watch_set::iterator iter = _watchset.begin(); iter != _watchset.end(); ++iter)
{
const ibrcommon::File &path = (*iter);
std::list<ibrcommon::File> files;
if (path.getFiles(files) == 0)
{
for (std::list<ibrcommon::File>::iterator iter = files.begin(); iter != files.end(); ++iter)
{
watch_set.insert(*iter);
}
}
else
{
IBRCOMMON_LOGGER_TAG("FileMonitor", error) << "scan of " << path.getPath() << " failed" << IBRCOMMON_LOGGER_ENDL;
}
}
// check for new directories
for (std::set<ibrcommon::File>::iterator iter = watch_set.begin(); iter != watch_set.end(); ++iter)
{
const ibrcommon::File &path = (*iter);
if (path.isDirectory() && !path.isSystem())
{
if (!isActive(path)) {
adopt(path);
}
}
}
// look for gone directories
for (std::map<ibrcommon::File, dtn::core::Node>::iterator iter = _active_paths.begin(); iter != _active_paths.end();)
{
const ibrcommon::File &path = (*iter).first;
const dtn::core::Node &node = (*iter).second;
if (watch_set.find(path) == watch_set.end())
{
dtn::core::BundleCore::getInstance().getConnectionManager().remove(node);
IBRCOMMON_LOGGER_DEBUG_TAG("FileMonitor", 5) << "Node on drive gone: " << node.getEID().getString() << IBRCOMMON_LOGGER_ENDL;
_active_paths.erase(iter++);
}
else
{
++iter;
}
}
}
void NativeSession::getInfo(RegisterIndex ri) throw ()
{
ibrcommon::RWLock l(_cb_mutex, ibrcommon::RWMutex::LOCK_READONLY);
if (_serializer_cb == NULL) return;
NativeSerializer serializer(*_serializer_cb, NativeSerializer::BUNDLE_INFO);
try {
serializer << _bundle[ri];
} catch (const ibrcommon::Exception &ex) {
IBRCOMMON_LOGGER_TAG(NativeSession::TAG, error) << "Get failed " << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
/**
* 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;
}
}
}
void EpidemicRoutingExtension::componentDown() throw ()
{
dtn::core::EventDispatcher<dtn::routing::NodeHandshakeEvent>::remove(this);
try {
// stop the thread
stop();
join();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG(EpidemicRoutingExtension::TAG, error) << "componentDown failed: " << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
RSASHA256Stream::traits::int_type RSASHA256Stream::overflow(RSASHA256Stream::traits::int_type c)
{
char *ibegin = &out_buf_[0];
char *iend = pptr();
// mark the buffer as free
setp(&out_buf_[0], &out_buf_[BUFF_SIZE - 1]);
if (!std::char_traits<char>::eq_int_type(c, std::char_traits<char>::eof()))
{
//TODO writing one byte after the buffer?
*iend++ = std::char_traits<char>::to_char_type(c);
}
// if there is nothing to send, just return
if ((iend - ibegin) == 0)
{
return std::char_traits<char>::not_eof(c);
}
if (!_verify)
// hashing
{
if (!EVP_SignUpdate(&_ctx, &out_buf_[0], iend - ibegin))
{
IBRCOMMON_LOGGER_TAG("RSASHA256Stream", critical) << "failed to feed data into the signature function" << IBRCOMMON_LOGGER_ENDL;
ERR_print_errors_fp(stderr);
}
}
else
{
if (!EVP_VerifyUpdate(&_ctx, &out_buf_[0], iend - ibegin))
{
IBRCOMMON_LOGGER_TAG("RSASHA256Stream", critical) << "failed to feed data into the verification function" << IBRCOMMON_LOGGER_ENDL;
ERR_print_errors_fp(stderr);
}
}
return std::char_traits<char>::not_eof(c);
}
void FloodRoutingExtension::componentUp() throw ()
{
// reset the task queue
_taskqueue.reset();
// routine checked for throw() on 15.02.2013
try {
// run the thread
start();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG(FloodRoutingExtension::TAG, error) << "componentUp failed: " << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
}
void IPNDAgent::unlisten(const ibrcommon::vinterface &iface) throw ()
{
ibrcommon::socketset socks = _send_socket.get(iface);
for (ibrcommon::socketset::iterator iter = socks.begin(); iter != socks.end(); ++iter) {
ibrcommon::udpsocket *sock = dynamic_cast<ibrcommon::udpsocket*>(*iter);
_send_socket.remove(sock);
try {
sock->down();
} catch (const ibrcommon::socket_exception &ex) {
IBRCOMMON_LOGGER_TAG(IPNDAgent::TAG, warning) << ex.what() << IBRCOMMON_LOGGER_ENDL;
}
delete sock;
}
}
void TCPConnection::shutdown() throw ()
{
try {
// shutdown
(*getProtocolStream()).shutdown(dtn::streams::StreamConnection::CONNECTION_SHUTDOWN_ERROR);
} catch (const ibrcommon::Exception&) {};
try {
// abort the connection thread
ibrcommon::DetachedThread::stop();
} catch (const ibrcommon::ThreadException &ex) {
IBRCOMMON_LOGGER_TAG(TCPConnection::TAG, error) << "shutdown failed (" << ex.what() << ")" << IBRCOMMON_LOGGER_ENDL;
}
}
