BaseRouter.h

Go to the documentation of this file.

/*
 * BaseRouter.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@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 BASEROUTER_H_
#define BASEROUTER_H_

#include "Component.h"
#include "routing/NeighborDatabase.h"
#include "routing/NodeHandshake.h"
#include "core/EventReceiver.h"
#include "storage/BundleStorage.h"
#include "storage/BundleSeeker.h"

#include "routing/RoutingExtension.h"
#include "routing/NodeHandshakeExtension.h"
#include "routing/RetransmissionExtension.h"

#include <ibrdtn/data/BundleSet.h>
#include <ibrdtn/data/DTNTime.h>
#include <ibrdtn/data/BundleID.h>
#include <ibrdtn/data/MetaBundle.h>

#include <ibrcommon/thread/Thread.h>
#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/thread/RWMutex.h>
#include <ibrcommon/thread/Conditional.h>


namespace dtn
{
        namespace routing
        {
                class BaseRouter : public dtn::core::EventReceiver, public dtn::daemon::IntegratedComponent
                {
                        static const std::string TAG;

                public:
                        class RoutingException : public ibrcommon::Exception
                        {
                                public:
                                        RoutingException(string what = "An error occured during routing.") throw() : Exception(what)
                                        {
                                        };
                        };

                        class NoNeighbourFoundException : public RoutingException
                        {
                                public:
                                        NoNeighbourFoundException(string what = "No neighbour was found.") throw() : RoutingException(what)
                                        {
                                        };
                        };

                        class NoRouteFoundException : public RoutingException
                        {
                                public:
                                        NoRouteFoundException(string what = "No route found.") throw() : RoutingException(what)
                                        {
                                        };
                        };

                        typedef std::set<RoutingExtension*> extension_list;

                        BaseRouter();
                        ~BaseRouter();

                        void add(RoutingExtension *extension);

                        void remove(RoutingExtension *extension);

                        const extension_list& getExtensions() const;

                        ibrcommon::RWMutex& getExtensionMutex() throw ();

                        void clearExtensions();

                        void raiseEvent(const dtn::core::Event *evt) throw ();

                        dtn::storage::BundleStorage &getStorage();

                        dtn::storage::BundleSeeker &getSeeker();

                        void doHandshake(const dtn::data::EID &eid);

                        bool isKnown(const dtn::data::BundleID &id);

                        bool filterKnown(const dtn::data::MetaBundle &meta);

                        void setKnown(const dtn::data::MetaBundle &meta);

                        const dtn::data::BundleSet getKnownBundles();

                        const dtn::data::BundleSet getPurgedBundles();

                        void setPurged(const dtn::data::MetaBundle &meta);

                        bool isPurged(const dtn::data::BundleID &id);

                        virtual const std::string getName() const;

                        NeighborDatabase& getNeighborDB();

                        void extensionsUp() throw ();

                        void extensionsDown() throw ();

                        void processHandshake(const dtn::data::EID &source, NodeHandshake &answer);

                        void responseHandshake(const dtn::data::EID&, const NodeHandshake&, NodeHandshake&);

                        void requestHandshake(const dtn::data::EID &destination, NodeHandshake &request);


                protected:
                        virtual void componentUp() throw ();
                        virtual void componentDown() throw ();

                private:
                        void __forward_event(const dtn::core::Event *evt) throw ();

                        ibrcommon::Mutex _known_bundles_lock;
                        dtn::data::BundleSet _known_bundles;

                        ibrcommon::Mutex _purged_bundles_lock;
                        dtn::data::BundleSet _purged_bundles;

                        ibrcommon::RWMutex _extensions_mutex;
                        extension_list _extensions;

                        // this is true if the extensions are up
                        bool _extension_state;

                        NeighborDatabase _neighbor_database;
                        NodeHandshakeExtension _nh_extension;
                        RetransmissionExtension _retransmission_extension;

                        dtn::data::Timestamp _next_expiration;
                };
        }
}


#endif /* BASEROUTER_H_ */