DHTNameService.h

Go to the documentation of this file.

/*
 * DHTNameService.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Till Lorentzen <lorenzte@ibr.cs.tu-bs.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#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 "core/EventReceiver.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) throw ();
        void update(const ibrcommon::vinterface &iface, DiscoveryAnnouncement &announcement)
                        throw (dtn::net::DiscoveryServiceProvider::NoServiceHereException);


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

#endif /* DHTNAMESERVICE_H_ */