daemon/src/net/DatagramConvergenceLayer.h

Go to the documentation of this file.

/*
 * DatagramConvergenceLayer.h
 *
 *  Created on: 21.11.2011
 *      Author: morgenro
 */

#ifndef DATAGRAMCONVERGENCELAYER_H_
#define DATAGRAMCONVERGENCELAYER_H_

#include "Component.h"
#include "net/DatagramConnection.h"
#include "net/ConvergenceLayer.h"
#include "net/DiscoveryAgent.h"
#include "net/DiscoveryServiceProvider.h"
#include "net/DatagramConnectionParameter.h"
#include "core/Node.h"
#include <ibrcommon/net/vinterface.h>

#include <list>

namespace dtn
{
        namespace net
        {
                class DatagramService
                {
                public:
                        enum FLOWCONTROL
                        {
                                FLOW_NONE = 0,
                                FLOW_STOPNWAIT = 1
                        };

                        virtual ~DatagramService() {};

                        virtual void bind() throw (DatagramException) = 0;

                        virtual void shutdown() = 0;

                        virtual void send(const char &type, const char &flags, const unsigned int &seqno, const std::string &address, const char *buf, size_t length) throw (DatagramException) = 0;

                        virtual void send(const char &type, const char &flags, const unsigned int &seqno, const char *buf, size_t length) throw (DatagramException) = 0;

                        virtual size_t recvfrom(char *buf, size_t length, char &type, char &flags, unsigned int &seqno, std::string &address) throw (DatagramException) = 0;

                        virtual const std::string getServiceTag() const = 0;

                        virtual const std::string getServiceDescription() const = 0;

                        virtual const ibrcommon::vinterface& getInterface() const = 0;

                        virtual dtn::core::Node::Protocol getProtocol() const = 0;

                        virtual const DatagramConnectionParameter& getParameter() const = 0;
                };

                class DatagramConvergenceLayer : public ConvergenceLayer, public dtn::daemon::IndependentComponent,
                        public EventReceiver, public DatagramConnectionCallback
                {
                public:
                        enum HEADER_FLAGS
                        {
                                HEADER_UNKOWN = 0,
                                HEADER_BROADCAST = 1,
                                HEADER_SEGMENT = 2,
                                HEADER_ACK = 4
                        };

                        DatagramConvergenceLayer(DatagramService *ds);
                        virtual ~DatagramConvergenceLayer();

                        dtn::core::Node::Protocol getDiscoveryProtocol() const;

                        void queue(const dtn::core::Node &n, const ConvergenceLayer::Job &job);

                        virtual const std::string getName() const;

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

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

                        void sendAnnoucement();

                        void callback_send(DatagramConnection &connection, const char &flags, const unsigned int &seqno, const std::string &destination, const char *buf, int len) throw (DatagramException);

                        void callback_ack(DatagramConnection &connection, const unsigned int &seqno, const std::string &destination) throw (DatagramException);

                        void connectionUp(const DatagramConnection *conn);
                        void connectionDown(const DatagramConnection *conn);

                private:
                        DatagramConnection& getConnection(const std::string &identifier);

                        DatagramService *_service;

                        ibrcommon::Mutex _send_lock;

                        ibrcommon::Conditional _connection_cond;
                        std::list<DatagramConnection*> _connections;

                        bool _running;

                        u_int16_t _discovery_sn;
                };
        } /* namespace data */
} /* namespace dtn */
#endif /* DATAGRAMCONVERGENCELAYER_H_ */