daemon/src/net/DHTNameService.h

Go to the documentation of this file.

/*
 * DHTNameService.h
 *
 *  Created on: 21.11.2011
 *      Author: Till Lorentzen
 */

#ifndef DHTNAMESERVICE_H_
#define DHTNAMESERVICE_H_

#define DHT_RESULTS_EXPIRE_TIMEOUT 600
#define DHT_PATH_EXPIRE_TIMEOUT 60
#define DHT_DISCOVERED_NODE_PRIORITY 3

#include "Component.h"
#include "Configuration.h"
#include "core/Event.h"
#include "net/DiscoveryServiceProvider.h"

#include <ibrdtn/data/EID.h>

#include <ibrcommon/thread/Mutex.h>

#include <string>
#include <list>

extern "C" {
#include <dtndht/dtndht.h>
}

namespace dtn {
namespace dht {
class DHTNameService: public dtn::daemon::IndependentComponent,
                public dtn::core::EventReceiver,
                public dtn::net::DiscoveryServiceProvider {
private:
        // All DHT configured sockets and needed setting are saved this structure
        struct dtn_dht_context _context;
        // Receiving buffer for DHT UDP packets
        unsigned char _buf[4096];
        // Helping pipe to interrupt the main loop select
        int _interrupt_pipe[2];
        // A little extra variable to signal main loop to exit on interrupt pipe
        bool _exiting;
        // true if the dht is correctly set up and ready for work
        bool _initialized;
        // true, if the dht was ready and I announced myself
        bool _announced;
        // A Mutex for the access to the dht lib
        ibrcommon::Mutex _libmutex;
        // Number of good and dubious DHT Nodes
        int _foundNodes;
        // A list of all lookups done before DHT is stable
        std::list<dtn::data::EID> cachedLookups;
        // Timestamp of the last bootstrapping call
        time_t _bootstrapped;
        // Configuration for the DHT
        const daemon::Configuration::DHT& _config;
        void lookup(const dtn::data::EID &eid);
        void announce(const dtn::core::Node &n, enum dtn_dht_lookup_type type);
        void deannounce(const dtn::core::Node &n);

        bool isNeighbourAnnouncable(const dtn::core::Node &n);
        bool setNonBlockingInterruptPipe(void);
        std::string getConvergenceLayerName(
                        const dtn::daemon::Configuration::NetConfig &net);
        void pingNode(const dtn::core::Node &n);
        std::list<std::string> getAllIPAddresses(const dtn::core::Node &n);

        void bootstrapping();

        void bootstrappingFile();

        void bootstrappingDNS();

        void bootstrappingIPs();

public:
        DHTNameService();
        virtual ~DHTNameService();
        const std::string getName() const;
        void raiseEvent(const dtn::core::Event *evt);
        void update(const ibrcommon::vinterface &iface, std::string &name,
                        std::string &data)
                        throw (dtn::net::DiscoveryServiceProvider::NoServiceHereException);


protected:
        void __cancellation();
        void componentUp();
        void componentRun();
        void componentDown();
};
}
}

#endif /* DHTNAMESERVICE_H_ */