source: source/ariba/overlay/messages/OverlayMsg.h@ 12746

// [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 OVERLAY_MSG_H__
#define OVERLAY_MSG_H__

#include <boost/cstdint.hpp>

#include "ariba/utility/messages.h"
#include "ariba/utility/serialization.h"
#include "ariba/utility/types/ServiceID.h"
#include "ariba/utility/types/NodeID.h"
#include "ariba/utility/types/LinkID.h"
// #include <ariba/utility/misc/sha1.h>
#include "ariba/overlay/SequenceNumber.h"

namespace ariba {
namespace overlay {

using ariba::utility::LinkID;
using ariba::utility::NodeID;
using ariba::utility::ServiceID;
using ariba::utility::Message;
//using ariba::communication::EndpointDescriptor;
using_serialization;

/**
 * A general purpose overlay message that is used to exchange messages
 * between nodes.
 *
 * @author Sebastian Mies <mies@tm.uka.de>, Mario Hock
 */
class OverlayMsg: public Message { VSERIALIZEABLE;
public:
        /// message types, is: uint8_t
        enum type_ { // is: uint8_t
                typeInvalid     = 0x00, ///< invalid, unspecified type

                // data transfer
                maskTransfer    = 0x10, ///< bit mask for transfer messages
                typeData        = 0x11, ///< message contains data for higher layers
                typeMessageLost = 0x12, ///< message contains info about a dropped message

                // join signaling
                maskJoin        = 0x20, ///< bit mask for join messages
                typeJoinRequest = 0x21, ///< join request
                typeJoinReply   = 0x22, ///< join reply

                // link messages
                maskLink        = 0x30, ///< bit mask for link messages
                typeLinkRequest = 0x31, ///< request a new link
                typeLinkReply   = 0x32, ///< link request reply
                typeLinkUpdate  = 0x33, ///< update message for link association
                typeLinkDirect  = 0x34, ///< direct connection has been established
                typeKeepAlive   = 0x35, ///< keep-alive message
                typeKeepAliveReply   = 0x36, ///< keep-alive message (replay)
                typeLinkClose   = 0x37,

                /// DHT routed messages
                /// @deprecated because the DHT has been moved into a separate service
                maskDHT                 = 0x40, ///< bit mask for dht messages
                typeDHTPut      = 0x41, ///< DHT put operation
                typeDHTGet      = 0x42, ///< DHT get operation
                typeDHTRemove   = 0x43, ///< DHT remove operation

                /// DHT response messages
                /// @deprecated because the DHT has been moved into a separate service
                maskDHTResponse = 0x50, ///< bit mask for dht responses
                typeDHTData     = 0x51, ///< DHT get data
        
        /// misc message types
        typePing        = 0x44,
        typePong        = 0x45,

                // topology signaling
                typeSignalingStart = 0x80, ///< start of the signaling types
                typeSignalingEnd = 0xFF    ///< end of the signaling types
        };
    
    /// message flags (uint8_t)
    enum flags_
    {
        flagRelayed         = 1 << 0,
        flagRegisterRelay   = 1 << 1,
        flagRouteRecord     = 1 << 2,
        flagSeqNum1         = 1 << 3,
        flagSeqNum2         = 1 << 4,
        flagAutoLink        = 1 << 5,
        flagLinkMessage     = 1 << 6,
        flagHasMoreFlags    = 1 << 7
    };

        /// default constructor
        OverlayMsg(
                uint8_t type = typeInvalid,
                const ServiceID& _service      = ServiceID::UNSPECIFIED,
                const NodeID& _sourceNode      = NodeID::UNSPECIFIED,
                const NodeID& _destinationNode = NodeID::UNSPECIFIED,
                const LinkID& _sourceLink      = LinkID::UNSPECIFIED,
                const LinkID& _destinationLink = LinkID::UNSPECIFIED )
    :   type(type), flags(0), extended_flags(0), hops(0), ttl(10), priority(0),
                service(_service),
                sourceNode(_sourceNode), destinationNode(_destinationNode),
                sourceLink(_sourceLink), destinationLink(_destinationLink),
                routeRecord() {
                if (!_sourceLink.isUnspecified() || !_destinationLink.isUnspecified())
                        setLinkMessage(true);
        }

        // copy constructor
        OverlayMsg(const OverlayMsg& rhs)
    :   type(rhs.type), flags(rhs.flags), extended_flags(rhs.extended_flags), 
        hops(rhs.hops), ttl(rhs.ttl),
                priority(rhs.priority), service(rhs.service),
                sourceNode(rhs.sourceNode), destinationNode(rhs.destinationNode),
                sourceLink(rhs.sourceLink), destinationLink(rhs.destinationLink),
                routeRecord(rhs.routeRecord) {
        }

        /// destructor
        ~OverlayMsg();

        /// type -------------------------------------------------------------------

        type_ getType() const {
                return (type_) type;
        }

        void setType( type_ type ) {
                this->type = type;
        }

        bool hasTypeMask( type_ mask ) const {
                return (type & (uint8_t)mask) == (uint8_t)mask;
        }

        /// priority ------------------------------------------------------------------
        
        uint8_t getPriority() const {
            return priority;
        }
        
        void setPriority(uint8_t priority) {
            this->priority = priority;
        }
        
        /// flags ------------------------------------------------------------------

        bool isRelayed() const {
        return (flags & flagRelayed)!=0;
        }

        void setRelayed( bool relayed = true ) {
        if (relayed) flags |= flagRelayed; else flags &= ~flagRelayed;
        }

        bool isRegisterRelay() const {
                return (flags & flagRegisterRelay)!=0;
        }

        void setRegisterRelay( bool relayed = true ) {
        if (relayed) flags |= flagRegisterRelay; else flags &= ~flagRegisterRelay;
        }

        bool isRouteRecord() const {
                return (flags & flagRouteRecord)!=0;
        }

        void setRouteRecord( bool route_record = true ) {
        if (route_record) flags |= flagRouteRecord; else flags &= ~flagRouteRecord;
        }

        bool isAutoLink() const {
        return (flags & flagAutoLink) == flagAutoLink;
        }

        void setAutoLink(bool auto_link = true ) {
        if (auto_link) flags |= flagAutoLink; else flags &= ~flagAutoLink;
        }

        bool isLinkMessage() const {
                return (flags & flagLinkMessage)!=0;
        }

        void setLinkMessage(bool link_info = true ) {
        if (link_info) flags |= flagLinkMessage; else flags &= ~flagLinkMessage;
        }
        
        bool hasExtendedFlags() const {
        return (flags & flagHasMoreFlags) == flagHasMoreFlags;
    }

        /// number of hops and time to live ----------------------------------------

        uint8_t getNumHops() const {
                return hops;
        }

        void setNumHops( uint8_t hops ) {
                this->hops = hops;
        }

        uint8_t increaseNumHops() {
                hops++;
                return hops;
        }

        uint8_t getTimeToLive() const {
                return ttl;
        }

        void setTimeToLive( uint8_t ttl ) {
                this->ttl = ttl;
        }

        /// addresses and links ----------------------------------------------------

        const ServiceID& getService() const {
                return service;
        }

        void setService( const ServiceID& service ) {
                this->service = service;
        }

        const NodeID& getSourceNode() const {
                return sourceNode;
        }

        void setSourceNode( const NodeID& node ) {
                this->sourceNode = node;
        }

        const NodeID& getDestinationNode() const {
                return destinationNode;
        }

        void setDestinationNode( const NodeID& node ) {
                this->destinationNode = node;
        }

        const LinkID& getSourceLink() const {
                return sourceLink;
        }

        void setSourceLink( const LinkID& link ) {
                this->sourceLink = link;
                setLinkMessage();
        }

        const LinkID& getDestinationLink() const {
                return destinationLink;
        }

        void setDestinationLink( const LinkID& link ) {
                this->destinationLink = link;
                setLinkMessage();
        }

        /// swaps source and destination
        void swapRoles() {
                NodeID dummyNode = sourceNode;
                sourceNode = destinationNode;
                destinationNode = dummyNode;
                LinkID dummyLink = sourceLink;
                sourceLink = destinationLink;
                destinationLink = dummyLink;
                hops = 0;
                routeRecord.clear();
        }

        const vector<NodeID> getRouteRecord() const {
                return routeRecord;
        }

        void addRouteRecord( const NodeID& node ) {
                if (isRouteRecord())
                        routeRecord.push_back(node);
        }
        
        /// sequence numbers
        bool hasShortSeqNum() const
    {
        return (flags & (flagSeqNum1 | flagSeqNum2)) == flagSeqNum1;
    }
    
    bool hasLongSeqNum() const
    {
        return (flags & (flagSeqNum1 | flagSeqNum2)) == flagSeqNum2;
    }
    
    void setSeqNum(const SequenceNumber& sequence_number)
    {
        this->seqnum = sequence_number;
        
        // short seqnum
        if ( sequence_number.isShortSeqNum() )
        {
            flags |= flagSeqNum1;
            flags &= ~flagSeqNum2;
        }
        // longseqnum
        else if ( sequence_number.isShortSeqNum() )
        {
            flags &= ~flagSeqNum1;
            flags |= flagSeqNum2;
        }
        // no seqnum
        else
        {
            flags &= ~flagSeqNum1;
            flags &= ~flagSeqNum2;
        }
    }
    
    const SequenceNumber& getSeqNum() const
    {
        return seqnum;
    }
    

private:
        uint8_t type, flags, extended_flags, hops, ttl, priority;
        ServiceID service;
        NodeID sourceNode;
        NodeID destinationNode;
        LinkID sourceLink;
        LinkID destinationLink;
//      EndpointDescriptor sourceEndpoint;
        vector<NodeID> routeRecord;
    SequenceNumber seqnum;
};

}} // ariba::overlay

/// serialization
sznBeginDefault( ariba::overlay::OverlayMsg, X ){
        // header
        X && type && flags;
    
    if ( hasExtendedFlags() )
        X && extended_flags;
    
    X && hops && ttl;

        // addresses
        X && &service && &sourceNode && &destinationNode;
        
        // priority
        X && priority;

        // message is associated with a end-to-end link
        if (isLinkMessage())
                X && &sourceLink && &destinationLink;

    
    /* seqnum */
    // serialize
    if ( X.isSerializer() )
    {
        if ( hasShortSeqNum() )
        {
            uint32_t short_seqnum;
            short_seqnum = seqnum.getShortSeqNum();
            X && short_seqnum;
        }
        if ( hasLongSeqNum() )
        {
            uint64_t long_seqnum;
            long_seqnum = seqnum.getLongSeqNum();
            X && long_seqnum;
        }
    }
    // deserialize
    else
    {
        if ( hasShortSeqNum() )
        {
            uint32_t short_seqnum;
            X && short_seqnum;
            seqnum = ariba::overlay::SequenceNumber(short_seqnum);
        }
        if ( hasLongSeqNum() )
        {
            uint64_t long_seqnum;
            X && long_seqnum;
            seqnum = ariba::overlay::SequenceNumber(long_seqnum);
        }        
    }
    
    
        // message should record its route
        if (isRouteRecord()) {
                uint8_t size = routeRecord.size();
                X && size;
                if (X.isDeserializer()) routeRecord.resize(size);
                for (uint8_t i=0;i<size; i++) X && &routeRecord[i];
        }

        // payload
//      X && Payload();
} sznEnd();

#endif // OVERLAY_MSG_H__