ibrdtn/ibrdtn/api/Client.h

Go to the documentation of this file.

/*
 * ApiClient.h
 *
 *  Created on: 24.06.2009
 *      Author: morgenro
 */


#ifndef CLIENT_H_
#define CLIENT_H_

#include "ibrdtn/api/Bundle.h"
#include "ibrdtn/data/Bundle.h"
#include "ibrdtn/streams/StreamConnection.h"
#include "ibrcommon/net/tcpstream.h"
#include "ibrcommon/thread/Mutex.h"
#include "ibrcommon/thread/MutexLock.h"
#include "ibrcommon/Exceptions.h"
#include "ibrcommon/thread/Queue.h"

using namespace dtn::data;
using namespace dtn::streams;

namespace dtn
{
        namespace api
        {
                class ConnectionException : public ibrcommon::Exception
                {
                public:
                        ConnectionException(string what = "A connection error occurred.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class ConnectionTimeoutException : public ibrcommon::Exception
                {
                public:
                        ConnectionTimeoutException(string what = "Timeout.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class ConnectionAbortedException : public ibrcommon::Exception
                {
                public:
                        ConnectionAbortedException(string what = "Aborted.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class Client : public StreamConnection, public StreamConnection::Callback
                {
                private:
                        class AsyncReceiver : public ibrcommon::JoinableThread
                        {
                        public:
                                AsyncReceiver(Client &client);
                                virtual ~AsyncReceiver();

                        protected:
                                void run();
                                bool __cancellation();

                        private:
                                Client &_client;
                        };

                        enum HANDSHAKE_FLAGS
                        {
                                HANDSHAKE_SENDONLY = 0x80
                        };


                public:
                        enum COMMUNICATION_MODE
                        {
                                MODE_BIDIRECTIONAL = 0,         // bidirectional
                                MODE_SENDONLY = 1                       // unidirectional, no reception of bundles
                        };

                        Client(COMMUNICATION_MODE mode, string app, ibrcommon::tcpstream &stream);
                        Client(string app, ibrcommon::tcpstream &stream);

                        virtual ~Client();

                        void connect();

                        bool isConnected();

                        void close();

                        virtual void eventShutdown(StreamConnection::ConnectionShutdownCases csc);
                        virtual void eventTimeout();
                        virtual void eventError();
                        virtual void eventConnectionUp(const StreamContactHeader &header);
                        virtual void eventConnectionDown();
                        virtual void eventBundleRefused();
                        virtual void eventBundleForwarded();
                        virtual void eventBundleAck(size_t ack);

                        dtn::api::Bundle getBundle(size_t timeout = 0);

                        size_t lastack;

                protected:
                        virtual void received(const dtn::streams::StreamContactHeader &h);
                        virtual void received(const dtn::api::Bundle &b);

                private:
                        ibrcommon::tcpstream &_stream;
                        COMMUNICATION_MODE _mode;
                        string _app;
                        bool _connected;
                        bool _async;
                        dtn::streams::StreamContactHeader _header;
                        Client::AsyncReceiver _receiver;

                        ibrcommon::Queue<dtn::api::Bundle> _inqueue;
                };
        }
}

#endif /* CLIENT_H_ */