/* ************************************************* * 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]); }