/* *************************************************
* Methode: menueAnzeigen()
************************************************* */
void GUI::menueAnzeigen() {
// Anwendungsstart: Controller-Objekte erzeugen
bootstrapping();
// Anzeige des Hauptmenues
while (true) {
cout << "***************************************" << endl;
cout << "* DarSys13: Darlehenssystem (SS13) *" << endl;
cout << "***************************************" << endl;
cout << "=== Hauptmenue ===" << endl << endl;
cout << "Bitte waehlen Sie:" << endl;
cout << "1 - Kundenverwaltung" << endl;
cout << "2 - Neues Darlehen anlegen" << endl;
cout << "3 - Alle bestehenden Darlehen anzeigen (Test)" << endl;
cout << "4 - Sicherungsverwaltung" << endl;
cout << "9 - Softwaretests durchfuehren (Test)" << endl;
cout << "0 - Beenden" << endl;
// Auswahl des Men�punktes
char eingabe = eingabeMenuepunkt();
// Funktionen ausf�hren
switch (eingabe) {
case '1':
kundenverwaltungMenu();
break;
case '2':
darlehenAnlegenGUI();
break;
case '3':
printDarlehen(); // Testmethode
break;
case '4':
SicherheitenMenu();
break;
case '9':
testsDurchfuehren(); // White-Box-Tests
break;
case '0':
return;
default:
cout << "Fehlerhafte Eingabe" << endl;
break;
}
}
}
void boot_server(char *str)
{
bootstrapping(NULL);
vtimer_usleep(1000*1000*2);
init_tcp_server_thread(NULL);
}
void dtn::dht::DHTNameService::componentRun() throw () {
if (!this->_initialized) {
IBRCOMMON_LOGGER_TAG("DHTNameService", error) << "DHT is not initialized"
<<IBRCOMMON_LOGGER_ENDL;
return;
}
std::string cltype_;
std::string port_;
const std::list<dtn::daemon::Configuration::NetConfig>
&nets =
dtn::daemon::Configuration::getInstance().getNetwork().getInterfaces();
// for every available interface, build the correct struct
for (std::list<dtn::daemon::Configuration::NetConfig>::const_iterator iter =
nets.begin(); iter != nets.end(); ++iter) {
try {
cltype_ = getConvergenceLayerName((*iter));
std::stringstream ss;
ss << (*iter).port;
port_ = ss.str();
struct dtn_convergence_layer * clstruct =
(struct dtn_convergence_layer*) malloc(
sizeof(struct dtn_convergence_layer));
clstruct->clname = (char*) malloc(cltype_.size());
clstruct->clnamelen = cltype_.size();
memcpy(clstruct->clname, cltype_.c_str(), cltype_.size());
struct dtn_convergence_layer_arg * arg =
(struct dtn_convergence_layer_arg*) malloc(
sizeof(struct dtn_convergence_layer_arg));
arg->key = (char*) malloc(5);
arg->key[4] = '\n';
#ifdef HAVE_VMIME
if(cltype_ == "email") {
memcpy(arg->key, "email", 5);
arg->keylen = 5;
const std::string &email =
dtn::daemon::Configuration::getInstance().getEMail().getOwnAddress();
arg->value = (char*) malloc(email.size());
memcpy(arg->value, email.c_str(), email.size());
arg->valuelen = email.size();
}else{
#endif
memcpy(arg->key, "port", 4);
arg->keylen = 4;
arg->value = (char*) malloc(port_.size());
memcpy(arg->value, port_.c_str(), port_.size());
arg->valuelen = port_.size();
#ifdef HAVE_VMIME
}
#endif
arg->next = NULL;
clstruct->args = arg;
clstruct->next = _context.clayer;
_context.clayer = clstruct;
} catch (const std::exception&) {
continue;
}
}
// Bootstrapping the DHT
int rc, numberOfRandomRequests = 0;
dtn::core::EventDispatcher<dtn::routing::QueueBundleEvent>::add(this);
dtn::core::EventDispatcher<dtn::core::NodeEvent>::add(this);
// DHT main loop
time_t tosleep = 0;
struct sockaddr_storage from;
socklen_t fromlen = sizeof(sockaddr_storage);
::memset(&from, 0, fromlen);
while (!this->_exiting) {
if (this->_foundNodes == 0) {
bootstrapping();
}
//Announce myself
if (!this->_announced && dtn_dht_ready_for_work(&_context) > 2) {
this->_announced = true;
if (!_config.isSelfAnnouncingEnabled())
return;
announce(dtn::core::BundleCore::local, SINGLETON);
// Read all unknown EIDs and lookup them
dtn::core::BundleCore &core = dtn::core::BundleCore::getInstance();
dtn::storage::BundleStorage & storage = core.getStorage();
std::set<dtn::data::EID> eids_ = storage.getDistinctDestinations();
std::set<dtn::data::EID>::iterator iterator;
for (iterator = eids_.begin(); iterator != eids_.end(); ++iterator) {
lookup(*iterator);
}
std::set<dtn::core::Node> neighbours_ = core.getConnectionManager().getNeighbors();
std::set<dtn::core::Node>::iterator neighbouriterator;
for (neighbouriterator = neighbours_.begin(); neighbouriterator
!= neighbours_.end(); ++neighbouriterator) {
if (isNeighbourAnnouncable(*neighbouriterator))
announce(*neighbouriterator, NEIGHBOUR);
}
while (!this->cachedLookups.empty()) {
lookup(this->cachedLookups.front());
this->cachedLookups.pop_front();
}
}
// Faster Bootstrapping by searching for random Keys
if (dtn_dht_ready_for_work(&_context) > 0 && dtn_dht_ready_for_work(
&_context) <= 2 && numberOfRandomRequests < 40) {
dtn_dht_start_random_lookup(&_context);
numberOfRandomRequests++;
}
struct timeval tv;
fd_set readfds;
tv.tv_sec = tosleep;
tv.tv_usec = random() % 1000000;
int high_fd = _interrupt_pipe[0];
FD_ZERO(&readfds);
FD_SET(_interrupt_pipe[0], &readfds);
if (_context.ipv4socket >= 0) {
FD_SET(_context.ipv4socket, &readfds);
high_fd = max(high_fd, _context.ipv4socket);
}
if (_context.ipv6socket >= 0) {
FD_SET(_context.ipv6socket, &readfds);
high_fd = max(high_fd, _context.ipv6socket);
}
rc = select(high_fd + 1, &readfds, NULL, NULL, &tv);
if (rc < 0) {
if (errno != EINTR) {
IBRCOMMON_LOGGER_TAG("DHTNameService", error)
<< "select of DHT Sockets failed with error: "
<< errno << IBRCOMMON_LOGGER_ENDL;
ibrcommon::Thread::sleep(1000);
}
}
if (FD_ISSET(_interrupt_pipe[0], &readfds)) {
IBRCOMMON_LOGGER_DEBUG_TAG("DHTNameService", 25) << "unblocked by self-pipe-trick"
<< IBRCOMMON_LOGGER_ENDL;
// this was an interrupt with the self-pipe-trick
char buf[2];
int read = ::read(_interrupt_pipe[0], buf, 2);
if (read <= 2 || _exiting)
break;
}
if (rc > 0) {
fromlen = sizeof(from);
if (_context.ipv4socket >= 0 && FD_ISSET(_context.ipv4socket,
&readfds))
rc = recvfrom(_context.ipv4socket, _buf, sizeof(_buf) - 1, 0,
(struct sockaddr*) &from, &fromlen);
else if (_context.ipv6socket >= 0 && FD_ISSET(_context.ipv6socket,
&readfds))
rc = recvfrom(_context.ipv6socket, _buf, sizeof(_buf) - 1, 0,
(struct sockaddr*) &from, &fromlen);
}
if (rc > 0) {
_buf[rc] = '\0';
{
ibrcommon::MutexLock l(this->_libmutex);
rc = dtn_dht_periodic(&_context, _buf, rc,
(struct sockaddr*) &from, fromlen, &tosleep);
}
} else {
{
ibrcommon::MutexLock l(this->_libmutex);
rc = dtn_dht_periodic(&_context, NULL, 0, NULL, 0, &tosleep);
}
}
int numberOfHosts = 0;
int numberOfGoodHosts = 0;
int numberOfGood6Hosts = 0;
unsigned int numberOfBlocksHosts = 0;
unsigned int numberOfBlocksHostsIPv4 = 0;
unsigned int numberOfBlocksHostsIPv6 = 0;
{
ibrcommon::MutexLock l(this->_libmutex);
if (_context.ipv4socket >= 0)
numberOfHosts
= dtn_dht_nodes(AF_INET, &numberOfGoodHosts, NULL);
if (_context.ipv6socket >= 0)
numberOfHosts += dtn_dht_nodes(AF_INET6, &numberOfGood6Hosts,
NULL);
numberOfBlocksHosts = dtn_dht_blacklisted_nodes(
&numberOfBlocksHostsIPv4, &numberOfBlocksHostsIPv6);
}
if (this->_foundNodes != numberOfHosts) {
if (_config.isBlacklistEnabled()) {
IBRCOMMON_LOGGER_DEBUG_TAG("DHTNameService", 42) << "DHT Nodes available: "
<< numberOfHosts << "(Good:" << numberOfGoodHosts
<< "+" << numberOfGood6Hosts << ") Blocked: "
<< numberOfBlocksHosts << "("
<< numberOfBlocksHostsIPv4 << "+"
<< numberOfBlocksHostsIPv6 << ")"
<< IBRCOMMON_LOGGER_ENDL;
} else {
IBRCOMMON_LOGGER_DEBUG_TAG("DHTNameService", 42) << "DHT Nodes available: "
<< numberOfHosts << "(Good:" << numberOfGoodHosts
<< "+" << numberOfGood6Hosts << ")"
<< IBRCOMMON_LOGGER_ENDL;
}
this->_foundNodes = numberOfHosts;
}
if (rc < 0) {
if (errno == EINTR) {
continue;
} else {
IBRCOMMON_LOGGER_TAG("DHTNameService", error) << "dtn_dht_periodic failed"
<< IBRCOMMON_LOGGER_ENDL;
if (rc == EINVAL || rc == EFAULT) {
IBRCOMMON_LOGGER_TAG("DHTNameService", error) << "DHT failed -> stopping DHT"
<< IBRCOMMON_LOGGER_ENDL;
break;
}
tosleep = 1;
}
}
}
dtn::core::EventDispatcher<dtn::routing::QueueBundleEvent>::remove(this);
dtn::core::EventDispatcher<dtn::core::NodeEvent>::remove(this);
this->_initialized = false;
if (_config.getPathToNodeFiles().size() > 0) {
ibrcommon::MutexLock l(this->_libmutex);
int save = dtn_dht_save_conf(_config.getPathToNodeFiles().c_str());
if (save != 0) {
IBRCOMMON_LOGGER_TAG("DHTNameService", warning) << "DHT could not save nodes"
<< IBRCOMMON_LOGGER_ENDL;
} else {
IBRCOMMON_LOGGER_DEBUG_TAG("DHTNameService", 25) << "DHT saved nodes"
<< IBRCOMMON_LOGGER_ENDL;
}
}
if (this->_announced && _config.isSelfAnnouncingEnabled())
deannounce(dtn::core::BundleCore::local);
dtn_dht_uninit();
IBRCOMMON_LOGGER_TAG("DHTNameService", info) << "DHT shut down" << IBRCOMMON_LOGGER_ENDL;
// Closes all sockets of the DHT
dtn_dht_close_sockets(&_context);
dtn_dht_free_convergence_layer_struct(_context.clayer);
IBRCOMMON_LOGGER_DEBUG_TAG("DHTNameService", 25) << "DHT sockets are closed"
<< IBRCOMMON_LOGGER_ENDL;
::close(_interrupt_pipe[0]);
::close(_interrupt_pipe[1]);
}
