source: source/ariba/communication/BaseCommunication.h@ 9991

// [License]
// The Ariba-Underlay Copyright
//
// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)
//
// Institute of Telematics
// UniversitÀt Karlsruhe (TH)
// Zirkel 2, 76128 Karlsruhe
// Germany
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the Institute of
// Telematics.
// [License]

#ifndef BASECOMMUNICATION_H_
#define BASECOMMUNICATION_H_

// boost & std includes
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <map>
#include <set>
#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/foreach.hpp>

// utilities
#include "ariba/utility/types.h"
#include "ariba/utility/messages.h"
#include "ariba/utility/logging/Logging.h"
#include "ariba/utility/misc/Demultiplexer.hpp"
#include "ariba/utility/system/SystemEventListener.h"

// new transport and addressing
#include "ariba/utility/addressing/addressing.hpp"
#include "ariba/utility/transport/transport.hpp"

// communication
#include "ariba/communication/CommunicationEvents.h"
#include "ariba/communication/EndpointDescriptor.h"
#include "ariba/communication/messages/AribaBaseMsg.h"

// network changes
#include "ariba/communication/networkinfo/NetworkChangeInterface.h"
#include "ariba/communication/networkinfo/NetworkChangeDetection.h"
#include "ariba/communication/networkinfo/NetworkInformation.h"

// disabled
//#ifndef UNDERLAY_OMNET
//  #include "ariba/communication/modules/transport/tcp/TCPTransport.h"
//  #include "ariba/communication/modules/network/ip/IPv4NetworkProtocol.h"
//  using ariba::communication::IPv4NetworkProtocol;
//  using ariba::communication::TCPTransport;
//#endif

namespace ariba {
  class SideportListener;
}

namespace ariba {
namespace communication {

using namespace std;
using namespace ariba::addressing;
using namespace ariba::transport;
using namespace ariba::utility;

// use base ariba types (clarifies multiple definitions)
using ariba::utility::Message;
using ariba::utility::seqnum_t;

/**
 * This class implements the Ariba Base Communication<br />
 *
 * Its primary task is to provide an abstraction to existing
 * protocols and addressing schemes.
 *
 * @author Sebastian Mies, Christoph Mayer
 */
class BaseCommunication:
        public NetworkChangeInterface,
        public SystemEventListener,
        public transport_listener {

        use_logging_h(BaseCommunication);
        friend class ariba::SideportListener;

public:
        /// Default ctor that just creates an non-functional base communication
        BaseCommunication();

        /// Default dtor that does nothing
        virtual ~BaseCommunication();

        /// Startup the base communication, start modules etc.
        void start();

        /// Stops the base communication, stop modules etc.
        void stop();

        /// Sets the endpoints
        void setEndpoints( string& endpoints );

        /// Check whether the base communication has been started up
        bool isStarted();

        /// Establishes a link to another end-point.
        const LinkID establishLink(const EndpointDescriptor& descriptor,
                const LinkID& linkid = LinkID::UNSPECIFIED, const QoSParameterSet& qos =
                                QoSParameterSet::DEFAULT, const SecurityParameterSet& sec =
                                SecurityParameterSet::DEFAULT);

        /// Drops a link
        void dropLink(const LinkID link);

        /**
         * Sends a message though an existing link to an end-point.
         *
         * @param lid The link identifier
         * @param message The message to be sent
         * @return A sequence number for this message
         */
        seqnum_t sendMessage(const LinkID lid, const Message* message);

        /**
         * Returns the end-point descriptor
         *
         * @param link the link id of the requested end-point
         * @return The end-point descriptor of the link's end-point
         */
        const EndpointDescriptor& getEndpointDescriptor(const LinkID link =
                        LinkID::UNSPECIFIED) const;

        /**
         * Get local links to the given endpoint of all local link
         * using the default parameter EndpointDescriptor::UNSPECIFIED
         * @param ep The remote endpoint to get all links to.
         * @return List of LinkID
         */
        LinkIDs getLocalLinks(const address_v* addr) const;

        /**
         * Registers a receiver.
         *
         * @param _receiver The receiving side
         */
        void registerMessageReceiver(MessageReceiver* receiver) {
                messageReceiver = receiver;
        }

        /**
         * Unregister a receiver.
         *
         * @param _receiver The receiving side
         */
        void unregisterMessageReceiver(MessageReceiver* receiver) {
                messageReceiver = NULL;
        }

        void registerEventListener(CommunicationEvents* _events);

        void unregisterEventListener(CommunicationEvents* _events);

        /// called when a system event is emitted by system queue
        virtual void handleSystemEvent(const SystemEvent& event);

        /// called when a message is received form transport_peer
        virtual void receive_message(transport_protocol* transport,
                const address_vf local, const address_vf remote, const uint8_t* data,
                size_t size);

protected:

        /// handle received message from a transport module
        void receiveMessage(const Message* message,
                const address_v* local, const address_v* remote );

        /// called when a network interface change happens
        virtual void onNetworkChange(
                const NetworkChangeInterface::NetworkChangeInfo& info);

private:
        /**
         * A link descriptor consisting of the end-point descriptor and currently
         * used underlay address.
         */
        class LinkDescriptor {
        public:

                /// default constructor
                LinkDescriptor() :
                        localLink(LinkID::UNSPECIFIED), localLocator(NULL),
                        remoteLink(LinkID::UNSPECIFIED), remoteLocator(NULL),
                        up(false) {
                }

                ~LinkDescriptor() {
                        if (localLocator!=NULL)  delete localLocator;
                        if (remoteLocator!=NULL) delete remoteLocator;
                }

                bool isUnspecified() const {
                        return (this == &UNSPECIFIED());
                }

                static LinkDescriptor& UNSPECIFIED(){
                        static LinkDescriptor* unspec = NULL;
                        if(unspec == NULL) unspec = new LinkDescriptor();
                        return *unspec;
                }

                bool unspecified;

                /// link identifiers
                LinkID localLink;
                const address_v* localLocator;

                /// used underlay addresses for the link
                LinkID remoteLink;
                const address_v* remoteLocator;

                /// the remote end-point descriptor
                EndpointDescriptor remoteEndpoint;

                /// flag, whether this link is up
                bool up;
        };

        /// Link management: list of links
        typedef vector<LinkDescriptor*> LinkSet;

        /// Link management: the set of currently managed links
        LinkSet linkSet;

        /// Link management: add a link
        void addLink( LinkDescriptor* link );

        /// Link management: remove a link
        void removeLink(const LinkID& localLink);

        /// Link management: get link information using the local link
        LinkDescriptor& queryLocalLink(const LinkID& localLink) const;

        /// Link management: get link information using the remote link
        LinkDescriptor& queryRemoteLink(const LinkID& remoteLink) const;

        /// The local end-point descriptor
        EndpointDescriptor localDescriptor;

#ifndef UNDERLAY_OMNET
        /// network change detector
        NetworkChangeDetection networkMonitor;
#endif

        /// list of all remote addresses of links to end-points
        class endpoint_reference {
        public:
                int count; ///< the number of open links to this end-point
                const address_v* endpoint; ///< the end-point itself
        };
        vector<endpoint_reference> remote_endpoints;

        /// adds an end-point to the list
        void add_endpoint( const address_v* endpoint );

        /// removes an end-point from the list
        void remove_endpoint( const address_v* endpoint );

        /// event listener
        typedef set<CommunicationEvents*> EventListenerSet;
        EventListenerSet eventListener;

        /// sequence numbers
        seqnum_t currentSeqnum;

        /// transport peer
        transport_peer* transport;

        /// the base overlay message receiver
        MessageReceiver* messageReceiver;

        /// convenience: send message to peer
        void send( Message* message, const EndpointDescriptor& endpoint );
        void send( Message* message, const LinkDescriptor& descriptor );

        /// state of the base communication
        bool started;

};

}} // namespace ariba, communication

#endif /* BASECOMMUNICATION_H_ */