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 ConnectionException
                {
                public:
                        ConnectionTimeoutException(string what = "Timeout.") throw() : ConnectionException(what)
                        {
                        };
                };

                class ConnectionAbortedException : public ConnectionException
                {
                public:
                        ConnectionAbortedException(string what = "Aborted.") throw() : ConnectionException(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:
                                // member variable for the reference to the client object
                                Client &_client;

                                bool _running;
                        };

                        enum HANDSHAKE_FLAGS
                        {
                                HANDSHAKE_NONE = 0x0,    
                                HANDSHAKE_SENDONLY = 0x80
                        };


                public:
                        enum COMMUNICATION_MODE
                        {
                                MODE_BIDIRECTIONAL = 0,         
                                MODE_SENDONLY = 1                       
                        };

                        Client(const std::string &app, ibrcommon::tcpstream &stream, const COMMUNICATION_MODE mode = MODE_BIDIRECTIONAL);

                        virtual ~Client();

                        void connect();

                        void close();

                        virtual void eventConnectionDown();

                        virtual void eventBundleAck(size_t ack);

                        virtual void eventShutdown(StreamConnection::ConnectionShutdownCases) {};

                        virtual void eventTimeout() {};

                        virtual void eventError() {};

                        virtual void eventConnectionUp(const StreamContactHeader&) {};

                        virtual void eventBundleRefused() {};

                        virtual void eventBundleForwarded() {};

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

                        // public variable
                        size_t lastack;

                protected:
                        virtual void received(const dtn::streams::StreamContactHeader&) {};

                        virtual void received(const dtn::api::Bundle &b);

                private:
                        // tcp stream reference to send/receive data to the daemon
                        ibrcommon::tcpstream &_stream;

                        // communication mode flags
                        COMMUNICATION_MODE _mode;

                        // own application suffix
                        string _app;

                        // The asynchronous receiver thread which receives incoming bundles
                        Client::AsyncReceiver _receiver;

                        // the queue for incoming bundles, when used in synchronous mode
                        ibrcommon::Queue<dtn::api::Bundle> _inqueue;
                };
        }
}

#endif /* CLIENT_H_ */