DatagramService.h

Go to the documentation of this file.

/*
 * DatagramService.h
 *
 *  Created on: 09.11.2012
 *      Author: morgenro
 */

#ifndef DATAGRAMSERVICE_H_
#define DATAGRAMSERVICE_H_

#include "core/Node.h"
#include <ibrcommon/net/vinterface.h>
#include <string>

namespace dtn
{
        namespace net
        {
                class DatagramException : public ibrcommon::Exception
                {
                public:
                        DatagramException(const std::string &what) : ibrcommon::Exception(what)
                        {};

                        virtual ~DatagramException() throw() {};
                };

                class WrongSeqNoException : public DatagramException
                {
                public:
                        WrongSeqNoException(size_t exp_seqno)
                        : DatagramException("Wrong sequence number received"), expected_seqno(exp_seqno)
                        {};

                        virtual ~WrongSeqNoException() throw() {};

                        const size_t expected_seqno;
                };

                class DatagramService
                {
                public:
                        enum FLOWCONTROL
                        {
                                FLOW_NONE = 0,
                                FLOW_STOPNWAIT = 1,
                                FLOW_SLIDING_WINDOW = 2
                        };

                        enum HEADER_FLAGS
                        {
                                SEGMENT_FIRST = 0x02,
                                SEGMENT_LAST = 0x01,
                                SEGMENT_MIDDLE = 0x00,
                                NACK_TEMPORARY = 0x04
                        };

                        class Parameter
                        {
                        public:
                                // default constructor
                                Parameter()
                                : flowcontrol(FLOW_NONE), max_seq_numbers(2), max_msg_length(1024),
                                  initial_timeout(50), seq_check(true), retry_limit(5) { }

                                // destructor
                                virtual ~Parameter() { }

                                FLOWCONTROL flowcontrol;
                                unsigned int max_seq_numbers;
                                size_t max_msg_length;
                                size_t initial_timeout;
                                bool seq_check;
                                size_t retry_limit;
                        };

                        virtual ~DatagramService() = 0;

                        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;

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

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

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

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

#endif /* DATAGRAMSERVICE_H_ */