TransportAddress.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef __TRANSPORTADDRESS_H_
#define __TRANSPORTADDRESS_H_

//#include <stdint.h>
#include <oversim_mapset.h>

#include <omnetpp.h>
#include <IPvXAddress.h>

class TransportAddress;
typedef std::vector<TransportAddress> TransportAddressVector;

class TransportAddress
{
public:

    class hashFcn
    {
    public:
        size_t operator()( const TransportAddress& h1 ) const
        {
            return h1.hash();
        }
    };

    // TODO: maybe we should use const uint8_t instead to save memory
    enum NatType {
        UNKNOWN_NAT = 0,
        NO_NAT = 1,
        FULL_CONE_NAT = 2,
        PORT_RESTRICTED_NAT = 3,
        SYMMETRIC_NAT = 4
    };

public://collection typedefs

    typedef UNORDERED_SET<TransportAddress, hashFcn> Set; 
protected://fields

    IPvXAddress ip; 
    int port; 
private:
    NatType natType; 
    // TODO: as soon as sourceRoute is used, we need to calculate the correct TransportAddress length for statistics */
    TransportAddressVector sourceRoute; 
public://construction

    TransportAddress();

    virtual ~TransportAddress() {};

    TransportAddress(const TransportAddress& handle);

    TransportAddress(const IPvXAddress& ip, int port = -1,
                     NatType natType = UNKNOWN_NAT);

public://static fields

    static const TransportAddress UNSPECIFIED_NODE; 
    static const TransportAddressVector UNSPECIFIED_NODES;

public://methods: delegates to OverlayKey and IPvXAddress

    bool operator==(const TransportAddress& rhs) const;

    bool operator!=(const TransportAddress& rhs) const;

    bool operator< (const TransportAddress& rhs) const;

    bool operator> (const TransportAddress& rhs) const;

    bool operator<=(const TransportAddress& rhs) const;

    bool operator>=(const TransportAddress& rhs) const;

public://methods: operators

    TransportAddress& operator=(const TransportAddress& rhs);

public://methods: setters and getters

    void setIp(const IPvXAddress& ip, int port = -1,
               NatType natType = UNKNOWN_NAT);

    void setAddress(const IPvXAddress& ip, int port = -1,
                    NatType natType = UNKNOWN_NAT) __attribute ((deprecated))
                    { setIp(ip, port, natType); };

    void appendSourceRoute(const TransportAddress& sourceRoute);

    void clearSourceRoute() { sourceRoute.clear(); };

    void setPort( int port );

    const IPvXAddress& getIp() const;

    const IPvXAddress& getAddress() const __attribute ((deprecated))
            { return getIp(); };

    int getPort() const;

    NatType getNatType() const;

    size_t getSourceRouteSize() const;

    const TransportAddressVector& getSourceRoute() const;

    bool isUnspecified() const;

public://methods: hashing

    size_t hash() const;

public://methods: c++ streaming

    friend std::ostream& operator<<(std::ostream& os, const TransportAddress& n);

private://methods:

    void assertUnspecified( const TransportAddress& handle ) const;

public:

    virtual TransportAddress* dup() const;
};

inline void doPacking(cCommBuffer *buf, TransportAddress& addr)
{
    doPacking(buf, addr.getIp());
    doPacking(buf, addr.getPort());
    doPacking(buf, static_cast<uint8_t>(addr.getNatType()));
    doPacking(buf, static_cast<uint8_t>(addr.getSourceRouteSize()));
    for (size_t i = 0; i < addr.getSourceRouteSize(); i++) {
        // TODO: ugly const_cast should be avoided
        doPacking(buf, const_cast<TransportAddress&>(addr.getSourceRoute()[i]));
    }
}

inline void doUnpacking(cCommBuffer *buf, TransportAddress& addr)
{
    IPvXAddress ip;
    int port;
    uint8_t natType = 0;
    doUnpacking(buf, ip);
    doUnpacking(buf, port);
    doUnpacking(buf, natType);
    addr.setIp(ip, port, static_cast<TransportAddress::NatType>(natType));

    uint8_t sourceRouteSize;
    TransportAddress sourceRouteEntry;
    doUnpacking(buf, sourceRouteSize);
    for (size_t i = 0; i < sourceRouteSize; i++) {
        doUnpacking(buf, sourceRouteEntry);
        addr.appendSourceRoute(sourceRouteEntry);
    }
}


#endif