inet::Gpsr Class Reference

This class implements the Greedy Perimeter Stateless Routing for Wireless Networks. More...

#include <Gpsr.h>

Inheritance diagram for inet::Gpsr:

Public Member Functions
	Gpsr ()
virtual	~Gpsr ()
Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::NetfilterBase::HookBase
virtual	~HookBase ()
void	registeredTo (INetfilter *nf)
void	unregisteredFrom (INetfilter *nf)
bool	isRegisteredHook (INetfilter *nf)
Public Member Functions inherited from inet::INetfilter::IHook
virtual	~IHook ()

Protected Member Functions
virtual int	numInitStages () const override
void	initialize (int stage) override
void	handleMessageWhenUp (cMessage *message) override
Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Private Member Functions
void	processSelfMessage (cMessage *message)
void	processMessage (cMessage *message)
void	scheduleBeaconTimer ()
void	processBeaconTimer ()
void	schedulePurgeNeighborsTimer ()
void	processPurgeNeighborsTimer ()
void	sendUdpPacket (Packet *packet)
void	processUdpPacket (Packet *packet)
const Ptr< GpsrBeacon >	createBeacon ()
void	sendBeacon (const Ptr< GpsrBeacon > &beacon)
void	processBeacon (Packet *packet)
GpsrOption *	createGpsrOption (L3Address destination)
int	computeOptionLength (GpsrOption *gpsrOption)
void	setGpsrOptionOnNetworkDatagram (Packet *packet, const Ptr< const NetworkHeaderBase > &networkHeader, GpsrOption *gpsrOption)
GpsrOption *	findGpsrOptionInNetworkDatagramForUpdate (const Ptr< NetworkHeaderBase > &networkHeader)
const GpsrOption *	findGpsrOptionInNetworkDatagram (const Ptr< const NetworkHeaderBase > &networkHeader) const
GpsrOption *	getGpsrOptionFromNetworkDatagramForUpdate (const Ptr< NetworkHeaderBase > &networkHeader)
const GpsrOption *	getGpsrOptionFromNetworkDatagram (const Ptr< const NetworkHeaderBase > &networkHeader) const
void	configureInterfaces ()
Coord	lookupPositionInGlobalRegistry (const L3Address &address) const
void	storePositionInGlobalRegistry (const L3Address &address, const Coord &position) const
void	storeSelfPositionInGlobalRegistry () const
Coord	computeIntersectionInsideLineSegments (Coord &begin1, Coord &end1, Coord &begin2, Coord &end2) const
Coord	getNeighborPosition (const L3Address &address) const
double	getVectorAngle (Coord vector) const
double	getNeighborAngle (const L3Address &address) const
std::string	getHostName () const
L3Address	getSelfAddress () const
L3Address	getSenderNeighborAddress (const Ptr< const NetworkHeaderBase > &networkHeader) const
simtime_t	getNextNeighborExpiration ()
void	purgeNeighbors ()
std::vector< L3Address >	getPlanarNeighbors () const
std::vector< L3Address >	getPlanarNeighborsCounterClockwise (double startAngle) const
L3Address	findNextHop (const L3Address &destination, GpsrOption *gpsrOption)
L3Address	findGreedyRoutingNextHop (const L3Address &destination, GpsrOption *gpsrOption)
L3Address	findPerimeterRoutingNextHop (const L3Address &destination, GpsrOption *gpsrOption)
Result	routeDatagram (Packet *datagram, GpsrOption *gpsrOption)
virtual Result	datagramPreRoutingHook (Packet *datagram) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the lower layer. More...
virtual Result	datagramForwardHook (Packet *datagram) override
	This is the second hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual Result	datagramPostRoutingHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual Result	datagramLocalInHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the upper layer. More...
virtual Result	datagramLocalOutHook (Packet *datagram) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the upper layer. More...
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override

Private Attributes
GpsrPlanarizationMode	planarizationMode = static_cast<GpsrPlanarizationMode>(-1)
const char *	interfaces = nullptr
simtime_t	beaconInterval
simtime_t	maxJitter
simtime_t	neighborValidityInterval
bool	displayBubbles
cModule *	host = nullptr
opp_component_ptr< IMobility >	mobility
IL3AddressType *	addressType = nullptr
ModuleRefByPar< IInterfaceTable >	interfaceTable
const char *	outputInterface = nullptr
ModuleRefByPar< IRoutingTable >	routingTable
ModuleRefByPar< INetfilter >	networkProtocol
int	positionByteLength = -1
cMessage *	beaconTimer = nullptr
cMessage *	purgeNeighborsTimer = nullptr
PositionTable	neighborPositionTable

Static Private Attributes
static PositionTable	globalPositionTable

Additional Inherited Members
Public Types inherited from inet::INetfilter::IHook
enum	Type {   PREROUTING, LOCALIN, FORWARD, POSTROUTING,   LOCALOUT }
enum	Result { ACCEPT, DROP, QUEUE, STOLEN }
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer
Protected Attributes inherited from inet::NetfilterBase::HookBase
std::vector< INetfilter * >	netfilters

Detailed Description

This class implements the Greedy Perimeter Stateless Routing for Wireless Networks.

The implementation supports both GG and RNG planarization algorithms.

For more information on the routing algorithm, see the GPSR paper http://www.eecs.harvard.edu/~htk/publication/2000-mobi-karp-kung.pdf

Constructor & Destructor Documentation

Gpsr()

inet::Gpsr::Gpsr

(

)

{
}

~Gpsr()

inet::Gpsr::~Gpsr ( )

virtual

{
    cancelAndDelete(beaconTimer);
    cancelAndDelete(purgeNeighborsTimer);
}

Member Function Documentation

computeIntersectionInsideLineSegments()

Coord inet::Gpsr::computeIntersectionInsideLineSegments ( Coord &  begin1, Coord &  end1, Coord &  begin2, Coord &  end2  ) const

private

{
    // NOTE: we must explicitly avoid computing the intersection points inside due to double instability
    if (begin1 == begin2 || begin1 == end2 || end1 == begin2 || end1 == end2)
        return Coord::NIL;
    else {
        double x1 = begin1.x;
        double y1 = begin1.y;
        double x2 = end1.x;
        double y2 = end1.y;
        double x3 = begin2.x;
        double y3 = begin2.y;
        double x4 = end2.x;
        double y4 = end2.y;
        double a = determinant(x1, y1, x2, y2);
        double b = determinant(x3, y3, x4, y4);
        double c = determinant(x1 - x2, y1 - y2, x3 - x4, y3 - y4);
        double x = determinant(a, x1 - x2, b, x3 - x4) / c;
        double y = determinant(a, y1 - y2, b, y3 - y4) / c;
        if ((x <= x1 && x <= x2) || (x >= x1 && x >= x2) || (x <= x3 && x <= x4) || (x >= x3 && x >= x4) ||
            (y <= y1 && y <= y2) || (y >= y1 && y >= y2) || (y <= y3 && y <= y4) || (y >= y3 && y >= y4))
            return Coord::NIL;
        else
            return Coord(x, y, 0);
    }
}

Referenced by findPerimeterRoutingNextHop().

computeOptionLength()

int inet::Gpsr::computeOptionLength ( GpsrOption *  gpsrOption )

private

{
    // routingMode
    int routingModeBytes = 1;
    // destinationPosition, perimeterRoutingStartPosition, perimeterRoutingForwardPosition
    int positionsBytes = 3 * positionByteLength;
    // currentFaceFirstSenderAddress, currentFaceFirstReceiverAddress, senderAddress
    int addressesBytes = 3 * getSelfAddress().getAddressType()->getAddressByteLength();
    // type and length
    int tlBytes = 1 + 1;
 
    return tlBytes + routingModeBytes + positionsBytes + addressesBytes;
}

Referenced by createGpsrOption().

configureInterfaces()

void inet::Gpsr::configureInterfaces ( )

private

{
    // join multicast groups
    cPatternMatcher interfaceMatcher(interfaces, false, true, false);
    for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
        NetworkInterface *networkInterface = interfaceTable->getInterface(i);
        if (networkInterface->isMulticast() && interfaceMatcher.matches(networkInterface->getInterfaceName()))
            networkInterface->joinMulticastGroup(addressType->getLinkLocalManetRoutersMulticastAddress());
    }
}

Referenced by handleStartOperation().

createBeacon()

const Ptr< GpsrBeacon > inet::Gpsr::createBeacon ( )

private

{
    const auto& beacon = makeShared<GpsrBeacon>();
    beacon->setAddress(getSelfAddress());
    beacon->setPosition(mobility->getCurrentPosition());
    beacon->setChunkLength(B(getSelfAddress().getAddressType()->getAddressByteLength() + positionByteLength));
    return beacon;
}

Referenced by processBeaconTimer().

createGpsrOption()

GpsrOption * inet::Gpsr::createGpsrOption ( L3Address  destination )

private

{
    GpsrOption *gpsrOption = new GpsrOption();
    gpsrOption->setRoutingMode(GPSR_GREEDY_ROUTING);
    gpsrOption->setDestinationPosition(lookupPositionInGlobalRegistry(destination));
    gpsrOption->setLength(computeOptionLength(gpsrOption));
    return gpsrOption;
}

Referenced by datagramLocalOutHook().

datagramForwardHook()

virtual Result inet::Gpsr::datagramForwardHook ( Packet *  datagram )

inlineoverrideprivatevirtual

This is the second hook called by the network protocol before it sends a datagram to the lower layer.

This is done after the datagramPreRoutingHook or the datagramLocalInHook is called and the datagram is routed.

Implements inet::INetfilter::IHook.

{ return ACCEPT; }

datagramLocalInHook()

virtual Result inet::Gpsr::datagramLocalInHook ( Packet *  datagram )

inlineoverrideprivatevirtual

This is the last hook called by the network protocol before it sends a datagram to the upper layer.

This is done after the datagramPreRoutingHook is called and the datagram is routed.

Implements inet::INetfilter::IHook.

{ return ACCEPT; }

datagramLocalOutHook()

INetfilter::IHook::Result inet::Gpsr::datagramLocalOutHook ( Packet *  datagram )

overrideprivatevirtual

This is the first hook called by the network protocol before it routes a datagram that was received from the upper layer.

The nextHopAddress is ignored when the outputNetworkInterface is a nullptr. After this is done

Implements inet::INetfilter::IHook.

{
    Enter_Method("datagramLocalOutHook");
    const auto& networkHeader = getNetworkProtocolHeader(packet);
    const L3Address& destination = networkHeader->getDestinationAddress();
    if (destination.isMulticast() || destination.isBroadcast() || routingTable->isLocalAddress(destination))
        return ACCEPT;
    else {
        GpsrOption *gpsrOption = createGpsrOption(networkHeader->getDestinationAddress());
        setGpsrOptionOnNetworkDatagram(packet, networkHeader, gpsrOption);
        return routeDatagram(packet, gpsrOption);
    }
}

datagramPostRoutingHook()

virtual Result inet::Gpsr::datagramPostRoutingHook ( Packet *  datagram )

inlineoverrideprivatevirtual

This is the last hook called by the network protocol before it sends a datagram to the lower layer.

Implements inet::INetfilter::IHook.

{ return ACCEPT; }

datagramPreRoutingHook()

INetfilter::IHook::Result inet::Gpsr::datagramPreRoutingHook ( Packet *  datagram )

overrideprivatevirtual

This is the first hook called by the network protocol before it routes a datagram that was received from the lower layer.

The nextHopAddress is ignored when the outputNetworkInterface is nullptr.

Implements inet::INetfilter::IHook.

{
    Enter_Method("datagramPreRoutingHook");
    const auto& networkHeader = getNetworkProtocolHeader(datagram);
    const L3Address& destination = networkHeader->getDestinationAddress();
    if (destination.isMulticast() || destination.isBroadcast() || routingTable->isLocalAddress(destination))
        return ACCEPT;
    else {
        // KLUDGE this allows overwriting the GPSR option inside
        auto gpsrOption = const_cast<GpsrOption *>(getGpsrOptionFromNetworkDatagram(networkHeader));
        return routeDatagram(datagram, gpsrOption);
    }
}

findGpsrOptionInNetworkDatagram()

const GpsrOption * inet::Gpsr::findGpsrOptionInNetworkDatagram ( const Ptr< const NetworkHeaderBase > &  networkHeader ) const

private

{
    const GpsrOption *gpsrOption = nullptr;
 
#ifdef INET_WITH_IPv4
    if (auto ipv4Header = dynamicPtrCast<const Ipv4Header>(networkHeader)) {
        gpsrOption = check_and_cast_nullable<const GpsrOption *>(ipv4Header->findOptionByType(IPOPTION_TLV_GPSR));
    }
    else
#endif
#ifdef INET_WITH_IPv6
    if (auto ipv6Header = dynamicPtrCast<const Ipv6Header>(networkHeader)) {
        const Ipv6HopByHopOptionsHeader *hdr = check_and_cast_nullable<const Ipv6HopByHopOptionsHeader *>(ipv6Header->findExtensionHeaderByType(IP_PROT_IPv6EXT_HOP));
        if (hdr != nullptr) {
            int i = (hdr->getTlvOptions().findByType(IPv6TLVOPTION_TLV_GPSR));
            if (i >= 0)
                gpsrOption = check_and_cast<const GpsrOption *>(hdr->getTlvOptions().getTlvOption(i));
        }
    }
    else
#endif
#ifdef INET_WITH_NEXTHOP
    if (auto nextHopHeader = dynamicPtrCast<const NextHopForwardingHeader>(networkHeader)) {
        int i = (nextHopHeader->getTlvOptions().findByType(NEXTHOP_TLVOPTION_TLV_GPSR));
        if (i >= 0)
            gpsrOption = check_and_cast<const GpsrOption *>(nextHopHeader->getTlvOptions().getTlvOption(i));
    }
    else
#endif
    {
    }
    return gpsrOption;
}

Referenced by getGpsrOptionFromNetworkDatagram().

findGpsrOptionInNetworkDatagramForUpdate()

GpsrOption * inet::Gpsr::findGpsrOptionInNetworkDatagramForUpdate ( const Ptr< NetworkHeaderBase > &  networkHeader )

private

{
    GpsrOption *gpsrOption = nullptr;
 
#ifdef INET_WITH_IPv4
    if (auto ipv4Header = dynamicPtrCast<Ipv4Header>(networkHeader)) {
        gpsrOption = check_and_cast_nullable<GpsrOption *>(ipv4Header->findMutableOptionByType(IPOPTION_TLV_GPSR));
    }
    else
#endif
#ifdef INET_WITH_IPv6
    if (auto ipv6Header = dynamicPtrCast<Ipv6Header>(networkHeader)) {
        Ipv6HopByHopOptionsHeader *hdr = check_and_cast_nullable<Ipv6HopByHopOptionsHeader *>(ipv6Header->findExtensionHeaderByTypeForUpdate(IP_PROT_IPv6EXT_HOP));
        if (hdr != nullptr) {
            int i = (hdr->getTlvOptions().findByType(IPv6TLVOPTION_TLV_GPSR));
            if (i >= 0)
                gpsrOption = check_and_cast<GpsrOption *>(hdr->getTlvOptionsForUpdate().getTlvOptionForUpdate(i));
        }
    }
    else
#endif
#ifdef INET_WITH_NEXTHOP
    if (auto nextHopHeader = dynamicPtrCast<NextHopForwardingHeader>(networkHeader)) {
        int i = (nextHopHeader->getTlvOptions().findByType(NEXTHOP_TLVOPTION_TLV_GPSR));
        if (i >= 0)
            gpsrOption = check_and_cast<GpsrOption *>(nextHopHeader->getTlvOptionsForUpdate().getTlvOptionForUpdate(i));
    }
    else
#endif
    {
    }
    return gpsrOption;
}

Referenced by getGpsrOptionFromNetworkDatagramForUpdate().

findGreedyRoutingNextHop()

L3Address inet::Gpsr::findGreedyRoutingNextHop ( const L3Address &  destination, GpsrOption *  gpsrOption  )

private

{
    EV_DEBUG << "Finding next hop using greedy routing: destination = " << destination << endl;
    L3Address selfAddress = getSelfAddress();
    Coord selfPosition = mobility->getCurrentPosition();
    Coord destinationPosition = gpsrOption->getDestinationPosition();
    double bestDistance = (destinationPosition - selfPosition).length();
    L3Address bestNeighbor;
    std::vector<L3Address> neighborAddresses = neighborPositionTable.getAddresses();
    for (auto& neighborAddress : neighborAddresses) {
        Coord neighborPosition = neighborPositionTable.getPosition(neighborAddress);
        double neighborDistance = (destinationPosition - neighborPosition).length();
        if (neighborDistance < bestDistance) {
            bestDistance = neighborDistance;
            bestNeighbor = neighborAddress;
        }
    }
    if (bestNeighbor.isUnspecified()) {
        EV_DEBUG << "Switching to perimeter routing: destination = " << destination << endl;
        if (displayBubbles && hasGUI())
            getContainingNode(host)->bubble("Switching to perimeter routing");
        gpsrOption->setRoutingMode(GPSR_PERIMETER_ROUTING);
        gpsrOption->setPerimeterRoutingStartPosition(selfPosition);
        gpsrOption->setPerimeterRoutingForwardPosition(selfPosition);
        gpsrOption->setCurrentFaceFirstSenderAddress(selfAddress);
        gpsrOption->setCurrentFaceFirstReceiverAddress(L3Address());
        return findPerimeterRoutingNextHop(destination, gpsrOption);
    }
    else
        return bestNeighbor;
}

Referenced by findNextHop(), and findPerimeterRoutingNextHop().

findNextHop()

L3Address inet::Gpsr::findNextHop ( const L3Address &  destination, GpsrOption *  gpsrOption  )

private

{
    switch (gpsrOption->getRoutingMode()) {
        case GPSR_GREEDY_ROUTING: return findGreedyRoutingNextHop(destination, gpsrOption);
        case GPSR_PERIMETER_ROUTING: return findPerimeterRoutingNextHop(destination, gpsrOption);
        default: throw cRuntimeError("Unknown routing mode");
    }
}

Referenced by routeDatagram().

findPerimeterRoutingNextHop()

L3Address inet::Gpsr::findPerimeterRoutingNextHop ( const L3Address &  destination, GpsrOption *  gpsrOption  )

private

{
    EV_DEBUG << "Finding next hop using perimeter routing: destination = " << destination << endl;
    L3Address selfAddress = getSelfAddress();
    Coord selfPosition = mobility->getCurrentPosition();
    Coord perimeterRoutingStartPosition = gpsrOption->getPerimeterRoutingStartPosition();
    Coord destinationPosition = gpsrOption->getDestinationPosition();
    double selfDistance = (destinationPosition - selfPosition).length();
    double perimeterRoutingStartDistance = (destinationPosition - perimeterRoutingStartPosition).length();
    if (selfDistance < perimeterRoutingStartDistance) {
        EV_DEBUG << "Switching to greedy routing: destination = " << destination << endl;
        if (displayBubbles && hasGUI())
            getContainingNode(host)->bubble("Switching to greedy routing");
        gpsrOption->setRoutingMode(GPSR_GREEDY_ROUTING);
        gpsrOption->setPerimeterRoutingStartPosition(Coord());
        gpsrOption->setPerimeterRoutingForwardPosition(Coord());
        gpsrOption->setCurrentFaceFirstSenderAddress(L3Address());
        gpsrOption->setCurrentFaceFirstReceiverAddress(L3Address());
        return findGreedyRoutingNextHop(destination, gpsrOption);
    }
    else {
        const L3Address& firstSenderAddress = gpsrOption->getCurrentFaceFirstSenderAddress();
        const L3Address& firstReceiverAddress = gpsrOption->getCurrentFaceFirstReceiverAddress();
        auto senderNeighborAddress = gpsrOption->getSenderAddress();
        auto neighborAngle = senderNeighborAddress.isUnspecified() ? getVectorAngle(destinationPosition - mobility->getCurrentPosition()) : getNeighborAngle(senderNeighborAddress);
        L3Address selectedNeighborAddress;
        std::vector<L3Address> neighborAddresses = getPlanarNeighborsCounterClockwise(neighborAngle);
        for (auto& neighborAddress : neighborAddresses) {
            Coord neighborPosition = getNeighborPosition(neighborAddress);
            Coord intersection = computeIntersectionInsideLineSegments(perimeterRoutingStartPosition, destinationPosition, selfPosition, neighborPosition);
            if (std::isnan(intersection.x)) {
                selectedNeighborAddress = neighborAddress;
                break;
            }
            else {
                EV_DEBUG << "Edge to next hop intersects: intersection = " << intersection << ", nextNeighbor = " << selectedNeighborAddress << ", firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
                gpsrOption->setCurrentFaceFirstSenderAddress(selfAddress);
                gpsrOption->setCurrentFaceFirstReceiverAddress(L3Address());
                gpsrOption->setPerimeterRoutingForwardPosition(intersection);
            }
        }
        if (selectedNeighborAddress.isUnspecified()) {
            EV_DEBUG << "No suitable planar graph neighbor found in perimeter routing: firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
            return L3Address();
        }
        else if (firstSenderAddress == selfAddress && firstReceiverAddress == selectedNeighborAddress) {
            EV_DEBUG << "End of perimeter reached: firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
            if (displayBubbles && hasGUI())
                getContainingNode(host)->bubble("End of perimeter reached");
            return L3Address();
        }
        else {
            if (gpsrOption->getCurrentFaceFirstReceiverAddress().isUnspecified())
                gpsrOption->setCurrentFaceFirstReceiverAddress(selectedNeighborAddress);
            return selectedNeighborAddress;
        }
    }
}

Referenced by findGreedyRoutingNextHop(), and findNextHop().

getGpsrOptionFromNetworkDatagram()

const GpsrOption * inet::Gpsr::getGpsrOptionFromNetworkDatagram ( const Ptr< const NetworkHeaderBase > &  networkHeader ) const

private

{
    const GpsrOption *gpsrOption = findGpsrOptionInNetworkDatagram(networkHeader);
    if (gpsrOption == nullptr)
        throw cRuntimeError("Gpsr option not found in datagram!");
    return gpsrOption;
}

Referenced by datagramPreRoutingHook(), and getSenderNeighborAddress().

getGpsrOptionFromNetworkDatagramForUpdate()

GpsrOption * inet::Gpsr::getGpsrOptionFromNetworkDatagramForUpdate ( const Ptr< NetworkHeaderBase > &  networkHeader )

private

{
    GpsrOption *gpsrOption = findGpsrOptionInNetworkDatagramForUpdate(networkHeader);
    if (gpsrOption == nullptr)
        throw cRuntimeError("Gpsr option not found in datagram!");
    return gpsrOption;
}

getHostName()

std::string inet::Gpsr::getHostName ( ) const

private

{
    return host->getFullName();
}

getNeighborAngle()

double inet::Gpsr::getNeighborAngle ( const L3Address &  address ) const

private

{
    return getVectorAngle(getNeighborPosition(address) - mobility->getCurrentPosition());
}

Referenced by findPerimeterRoutingNextHop().

getNeighborPosition()

Coord inet::Gpsr::getNeighborPosition ( const L3Address &  address ) const

private

{
    return neighborPositionTable.getPosition(address);
}

Referenced by findPerimeterRoutingNextHop(), and getNeighborAngle().

getNextNeighborExpiration()

simtime_t inet::Gpsr::getNextNeighborExpiration ( )

private

{
    simtime_t oldestPosition = neighborPositionTable.getOldestPosition();
    if (oldestPosition == SimTime::getMaxTime())
        return oldestPosition;
    else
        return oldestPosition + neighborValidityInterval;
}

Referenced by schedulePurgeNeighborsTimer().

getPlanarNeighbors()

std::vector< L3Address > inet::Gpsr::getPlanarNeighbors ( ) const

private

{
    std::vector<L3Address> planarNeighbors;
    std::vector<L3Address> neighborAddresses = neighborPositionTable.getAddresses();
    Coord selfPosition = mobility->getCurrentPosition();
    for (auto it = neighborAddresses.begin(); it != neighborAddresses.end(); it++) {
        auto neighborAddress = *it;
        Coord neighborPosition = neighborPositionTable.getPosition(neighborAddress);
        if (planarizationMode == GPSR_NO_PLANARIZATION)
            return neighborAddresses;
        else if (planarizationMode == GPSR_RNG_PLANARIZATION) {
            double neighborDistance = (neighborPosition - selfPosition).length();
            for (auto& witnessAddress : neighborAddresses) {
                Coord witnessPosition = neighborPositionTable.getPosition(witnessAddress);
                double witnessDistance = (witnessPosition - selfPosition).length();
                double neighborWitnessDistance = (witnessPosition - neighborPosition).length();
                if (neighborAddress == witnessAddress)
                    continue;
                else if (neighborDistance > std::max(witnessDistance, neighborWitnessDistance))
                    goto eliminate;
            }
        }
        else if (planarizationMode == GPSR_GG_PLANARIZATION) {
            Coord middlePosition = (selfPosition + neighborPosition) / 2;
            double neighborDistance = (neighborPosition - middlePosition).length();
            for (auto& witnessAddress : neighborAddresses) {
                Coord witnessPosition = neighborPositionTable.getPosition(witnessAddress);
                double witnessDistance = (witnessPosition - middlePosition).length();
                if (neighborAddress == witnessAddress)
                    continue;
                else if (witnessDistance < neighborDistance)
                    goto eliminate;
            }
        }
        else
            throw cRuntimeError("Unknown planarization mode");
        planarNeighbors.push_back(*it);
      eliminate:;
    }
    return planarNeighbors;
}

Referenced by getPlanarNeighborsCounterClockwise().

getPlanarNeighborsCounterClockwise()

std::vector< L3Address > inet::Gpsr::getPlanarNeighborsCounterClockwise ( double  startAngle ) const

private

{
    std::vector<L3Address> neighborAddresses = getPlanarNeighbors();
    std::sort(neighborAddresses.begin(), neighborAddresses.end(), [&] (const L3Address& address1, const L3Address& address2) {
        // NOTE: make sure the neighbor at startAngle goes to the end
        auto angle1 = getNeighborAngle(address1) - startAngle;
        auto angle2 = getNeighborAngle(address2) - startAngle;
        if (angle1 <= 0)
            angle1 += 2 * M_PI;
        if (angle2 <= 0)
            angle2 += 2 * M_PI;
        return angle1 < angle2;
    });
    return neighborAddresses;
}

Referenced by findPerimeterRoutingNextHop().

getSelfAddress()

L3Address inet::Gpsr::getSelfAddress ( ) const

private

{
    // TODO choose self address based on a new 'interfaces' parameter
    L3Address ret = routingTable->getRouterIdAsGeneric();
#ifdef INET_WITH_IPv6
    if (ret.getType() == L3Address::IPv6) {
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
            NetworkInterface *ie = interfaceTable->getInterface(i);
            if ((!ie->isLoopback())) {
                if (auto ipv6Data = ie->findProtocolData<Ipv6InterfaceData>()) {
                    ret = ipv6Data->getPreferredAddress();
                    break;
                }
            }
        }
    }
#endif
    return ret;
}

Referenced by computeOptionLength(), createBeacon(), findGreedyRoutingNextHop(), findPerimeterRoutingNextHop(), initialize(), processBeaconTimer(), routeDatagram(), sendBeacon(), and storeSelfPositionInGlobalRegistry().

getSenderNeighborAddress()

L3Address inet::Gpsr::getSenderNeighborAddress ( const Ptr< const NetworkHeaderBase > &  networkHeader ) const

private

{
    const GpsrOption *gpsrOption = getGpsrOptionFromNetworkDatagram(networkHeader);
    return gpsrOption->getSenderAddress();
}

getVectorAngle()

double inet::Gpsr::getVectorAngle ( Coord  vector ) const

private

{
    ASSERT(vector != Coord::ZERO);
    double angle = atan2(-vector.y, vector.x);
    if (angle < 0)
        angle += 2 * M_PI;
    return angle;
}

Referenced by findPerimeterRoutingNextHop(), and getNeighborAngle().

handleCrashOperation()

void inet::Gpsr::handleCrashOperation ( LifecycleOperation *  operation )

overrideprivatevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    neighborPositionTable.clear();
    cancelEvent(beaconTimer);
    cancelEvent(purgeNeighborsTimer);
}

handleMessageWhenUp()

void inet::Gpsr::handleMessageWhenUp ( cMessage *  message )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (message->isSelfMessage())
        processSelfMessage(message);
    else
        processMessage(message);
}

handleStartOperation()

void inet::Gpsr::handleStartOperation ( LifecycleOperation *  operation )

overrideprivatevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    configureInterfaces();
    storeSelfPositionInGlobalRegistry();
    scheduleBeaconTimer();
}

handleStopOperation()

void inet::Gpsr::handleStopOperation ( LifecycleOperation *  operation )

overrideprivatevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // TODO send a beacon to remove ourself from peers neighbor position table
    neighborPositionTable.clear();
    cancelEvent(beaconTimer);
    cancelEvent(purgeNeighborsTimer);
}

initialize()

void inet::Gpsr::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    if (stage == INITSTAGE_ROUTING_PROTOCOLS)
        addressType = getSelfAddress().getAddressType();
 
    RoutingProtocolBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        // Gpsr parameters
        const char *planarizationModeString = par("planarizationMode");
        if (!strcmp(planarizationModeString, ""))
            planarizationMode = GPSR_NO_PLANARIZATION;
        else if (!strcmp(planarizationModeString, "GG"))
            planarizationMode = GPSR_GG_PLANARIZATION;
        else if (!strcmp(planarizationModeString, "RNG"))
            planarizationMode = GPSR_RNG_PLANARIZATION;
        else
            throw cRuntimeError("Unknown planarization mode");
        interfaces = par("interfaces");
        beaconInterval = par("beaconInterval");
        maxJitter = par("maxJitter");
        neighborValidityInterval = par("neighborValidityInterval");
        displayBubbles = par("displayBubbles");
        // context
        host = getContainingNode(this);
        interfaceTable.reference(this, "interfaceTableModule", true);
        outputInterface = par("outputInterface");
        mobility = check_and_cast<IMobility *>(host->getSubmodule("mobility"));
        routingTable.reference(this, "routingTableModule", true);
        networkProtocol.reference(this, "networkProtocolModule", true);
        // internal
        beaconTimer = new cMessage("BeaconTimer");
        purgeNeighborsTimer = new cMessage("PurgeNeighborsTimer");
        // packet size
        positionByteLength = par("positionByteLength");
        // KLUDGE implement position registry protocol
        globalPositionTable.clear();
    }
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        registerProtocol(Protocol::manet, gate("ipOut"), gate("ipIn"));
        host->subscribe(linkBrokenSignal, this);
        networkProtocol->registerHook(0, this);
        WATCH(neighborPositionTable);
    }
}

lookupPositionInGlobalRegistry()

Coord inet::Gpsr::lookupPositionInGlobalRegistry ( const L3Address &  address ) const

private

{
    // KLUDGE implement position registry protocol
    return globalPositionTable.getPosition(address);
}

Referenced by createGpsrOption().

numInitStages()

virtual int inet::Gpsr::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processBeacon()

void inet::Gpsr::processBeacon ( Packet *  packet )

private

{
    const auto& beacon = packet->peekAtFront<GpsrBeacon>();
    EV_INFO << "Processing beacon: address = " << beacon->getAddress() << ", position = " << beacon->getPosition() << endl;
    neighborPositionTable.setPosition(beacon->getAddress(), beacon->getPosition());
    delete packet;
}

Referenced by processUdpPacket().

processBeaconTimer()

void inet::Gpsr::processBeaconTimer ( )

private

{
    EV_DEBUG << "Processing beacon timer" << endl;
    const L3Address selfAddress = getSelfAddress();
    if (!selfAddress.isUnspecified()) {
        sendBeacon(createBeacon());
        storeSelfPositionInGlobalRegistry();
    }
    scheduleBeaconTimer();
    schedulePurgeNeighborsTimer();
}

Referenced by processSelfMessage().

processMessage()

void inet::Gpsr::processMessage ( cMessage *  message )

private

{
    if (auto pk = dynamic_cast<Packet *>(message))
        processUdpPacket(pk);
    else
        throw cRuntimeError("Unknown message");
}

Referenced by handleMessageWhenUp().

processPurgeNeighborsTimer()

void inet::Gpsr::processPurgeNeighborsTimer ( )

private

{
    EV_DEBUG << "Processing purge neighbors timer" << endl;
    purgeNeighbors();
    schedulePurgeNeighborsTimer();
}

Referenced by processSelfMessage().

processSelfMessage()

void inet::Gpsr::processSelfMessage ( cMessage *  message )

private

{
    if (message == beaconTimer)
        processBeaconTimer();
    else if (message == purgeNeighborsTimer)
        processPurgeNeighborsTimer();
    else
        throw cRuntimeError("Unknown self message");
}

Referenced by handleMessageWhenUp().

processUdpPacket()

void inet::Gpsr::processUdpPacket ( Packet *  packet )

private

{
    packet->popAtFront<UdpHeader>();
    processBeacon(packet);
    schedulePurgeNeighborsTimer();
}

Referenced by processMessage().

purgeNeighbors()

void inet::Gpsr::purgeNeighbors ( )

private

{
    neighborPositionTable.removeOldPositions(simTime() - neighborValidityInterval);
}

Referenced by processPurgeNeighborsTimer().

receiveSignal()

void inet::Gpsr::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprivatevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == linkBrokenSignal) {
        EV_WARN << "Received link break" << endl;
        // TODO remove the neighbor
    }
}

routeDatagram()

INetfilter::IHook::Result inet::Gpsr::routeDatagram ( Packet *  datagram, GpsrOption *  gpsrOption  )

private

{
    const auto& networkHeader = getNetworkProtocolHeader(datagram);
    const L3Address& source = networkHeader->getSourceAddress();
    const L3Address& destination = networkHeader->getDestinationAddress();
    EV_INFO << "Finding next hop: source = " << source << ", destination = " << destination << endl;
    auto nextHop = findNextHop(destination, gpsrOption);
    datagram->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(nextHop);
    if (nextHop.isUnspecified()) {
        EV_WARN << "No next hop found, dropping packet: source = " << source << ", destination = " << destination << endl;
        if (displayBubbles && hasGUI())
            getContainingNode(host)->bubble("No next hop found, dropping packet");
        return DROP;
    }
    else {
        EV_INFO << "Next hop found: source = " << source << ", destination = " << destination << ", nextHop: " << nextHop << endl;
        gpsrOption->setSenderAddress(getSelfAddress());
        auto networkInterface = CHK(interfaceTable->findInterfaceByName(outputInterface));
        datagram->addTagIfAbsent<InterfaceReq>()->setInterfaceId(networkInterface->getInterfaceId());
        return ACCEPT;
    }
}

Referenced by datagramLocalOutHook(), and datagramPreRoutingHook().

scheduleBeaconTimer()

void inet::Gpsr::scheduleBeaconTimer ( )

private

{
    EV_DEBUG << "Scheduling beacon timer" << endl;
    scheduleAfter(beaconInterval + uniform(-1, 1) * maxJitter, beaconTimer);
}

Referenced by handleStartOperation(), and processBeaconTimer().

schedulePurgeNeighborsTimer()

void inet::Gpsr::schedulePurgeNeighborsTimer ( )

private

{
    EV_DEBUG << "Scheduling purge neighbors timer" << endl;
    simtime_t nextExpiration = getNextNeighborExpiration();
    if (nextExpiration == SimTime::getMaxTime()) {
        if (purgeNeighborsTimer->isScheduled())
            cancelEvent(purgeNeighborsTimer);
    }
    else {
        if (!purgeNeighborsTimer->isScheduled())
            scheduleAt(nextExpiration, purgeNeighborsTimer);
        else {
            if (purgeNeighborsTimer->getArrivalTime() != nextExpiration) {
                rescheduleAt(nextExpiration, purgeNeighborsTimer);
            }
        }
    }
}

Referenced by processBeaconTimer(), processPurgeNeighborsTimer(), and processUdpPacket().

sendBeacon()

void inet::Gpsr::sendBeacon ( const Ptr< GpsrBeacon > &  beacon )

private

{
    EV_INFO << "Sending beacon: address = " << beacon->getAddress() << ", position = " << beacon->getPosition() << endl;
    Packet *udpPacket = new Packet("GPSRBeacon");
    udpPacket->insertAtBack(beacon);
    auto udpHeader = makeShared<UdpHeader>();
    udpHeader->setSourcePort(GPSR_UDP_PORT);
    udpHeader->setDestinationPort(GPSR_UDP_PORT);
    udpHeader->setCrcMode(CRC_DISABLED);
    udpPacket->insertAtFront(udpHeader);
    auto addresses = udpPacket->addTag<L3AddressReq>();
    addresses->setSrcAddress(getSelfAddress());
    addresses->setDestAddress(addressType->getLinkLocalManetRoutersMulticastAddress());
    udpPacket->addTag<HopLimitReq>()->setHopLimit(255);
    udpPacket->addTag<PacketProtocolTag>()->setProtocol(&Protocol::manet);
    udpPacket->addTag<DispatchProtocolReq>()->setProtocol(addressType->getNetworkProtocol());
    sendUdpPacket(udpPacket);
}

Referenced by processBeaconTimer().

sendUdpPacket()

void inet::Gpsr::sendUdpPacket ( Packet *  packet )

private

{
    send(packet, "ipOut");
}

Referenced by sendBeacon().

setGpsrOptionOnNetworkDatagram()

void inet::Gpsr::setGpsrOptionOnNetworkDatagram ( Packet *  packet, const Ptr< const NetworkHeaderBase > &  networkHeader, GpsrOption *  gpsrOption  )

private

{
    packet->trimFront();
#ifdef INET_WITH_IPv4
    if (dynamicPtrCast<const Ipv4Header>(networkHeader)) {
        auto ipv4Header = removeNetworkProtocolHeader<Ipv4Header>(packet);
        gpsrOption->setType(IPOPTION_TLV_GPSR);
        B oldHlen = ipv4Header->calculateHeaderByteLength();
        ASSERT(ipv4Header->getHeaderLength() == oldHlen);
        ipv4Header->addOption(gpsrOption);
        B newHlen = ipv4Header->calculateHeaderByteLength();
        ipv4Header->setHeaderLength(newHlen);
        ipv4Header->addChunkLength(newHlen - oldHlen);
        ipv4Header->setTotalLengthField(ipv4Header->getTotalLengthField() + newHlen - oldHlen);
        insertNetworkProtocolHeader(packet, Protocol::ipv4, ipv4Header);
    }
    else
#endif
#ifdef INET_WITH_IPv6
    if (dynamicPtrCast<const Ipv6Header>(networkHeader)) {
        auto ipv6Header = removeNetworkProtocolHeader<Ipv6Header>(packet);
        gpsrOption->setType(IPv6TLVOPTION_TLV_GPSR);
        B oldHlen = ipv6Header->calculateHeaderByteLength();
        Ipv6HopByHopOptionsHeader *hdr = check_and_cast_nullable<Ipv6HopByHopOptionsHeader *>(ipv6Header->findExtensionHeaderByTypeForUpdate(IP_PROT_IPv6EXT_HOP));
        if (hdr == nullptr) {
            hdr = new Ipv6HopByHopOptionsHeader();
            hdr->setByteLength(B(8));
            ipv6Header->addExtensionHeader(hdr);
        }
        hdr->getTlvOptionsForUpdate().appendTlvOption(gpsrOption);
        hdr->setByteLength(B(utils::roundUp(2 + B(hdr->getTlvOptions().getLength()).get(), 8)));
        B newHlen = ipv6Header->calculateHeaderByteLength();
        ipv6Header->addChunkLength(newHlen - oldHlen);
        insertNetworkProtocolHeader(packet, Protocol::ipv6, ipv6Header);
    }
    else
#endif
#ifdef INET_WITH_NEXTHOP
    if (dynamicPtrCast<const NextHopForwardingHeader>(networkHeader)) {
        auto nextHopHeader = removeNetworkProtocolHeader<NextHopForwardingHeader>(packet);
        gpsrOption->setType(NEXTHOP_TLVOPTION_TLV_GPSR);
        int oldHlen = nextHopHeader->getTlvOptions().getLength();
        nextHopHeader->getTlvOptionsForUpdate().appendTlvOption(gpsrOption);
        int newHlen = nextHopHeader->getTlvOptions().getLength();
        nextHopHeader->addChunkLength(B(newHlen - oldHlen));
        insertNetworkProtocolHeader(packet, Protocol::nextHopForwarding, nextHopHeader);
    }
    else
#endif
    {
    }
}

Referenced by datagramLocalOutHook().

storePositionInGlobalRegistry()

void inet::Gpsr::storePositionInGlobalRegistry ( const L3Address &  address, const Coord &  position  ) const

private

{
    // KLUDGE implement position registry protocol
    globalPositionTable.setPosition(address, position);
}

Referenced by storeSelfPositionInGlobalRegistry().

storeSelfPositionInGlobalRegistry()

void inet::Gpsr::storeSelfPositionInGlobalRegistry ( ) const

private

{
    auto selfAddress = getSelfAddress();
    if (!selfAddress.isUnspecified())
        storePositionInGlobalRegistry(selfAddress, mobility->getCurrentPosition());
}

Referenced by handleStartOperation(), and processBeaconTimer().

Member Data Documentation

addressType

IL3AddressType* inet::Gpsr::addressType = nullptr

private

Referenced by configureInterfaces(), initialize(), and sendBeacon().

beaconInterval

simtime_t inet::Gpsr::beaconInterval

private

Referenced by initialize(), and scheduleBeaconTimer().

beaconTimer

cMessage* inet::Gpsr::beaconTimer = nullptr

private

Referenced by handleCrashOperation(), handleStopOperation(), initialize(), processSelfMessage(), scheduleBeaconTimer(), and ~Gpsr().

displayBubbles

bool inet::Gpsr::displayBubbles

private

Referenced by findGreedyRoutingNextHop(), findPerimeterRoutingNextHop(), initialize(), and routeDatagram().

globalPositionTable

PositionTable inet::Gpsr::globalPositionTable

staticprivate

Referenced by initialize(), lookupPositionInGlobalRegistry(), and storePositionInGlobalRegistry().

host

cModule* inet::Gpsr::host = nullptr

private

Referenced by findGreedyRoutingNextHop(), findPerimeterRoutingNextHop(), getHostName(), initialize(), and routeDatagram().

interfaces

const char* inet::Gpsr::interfaces = nullptr

private

Referenced by configureInterfaces(), and initialize().

interfaceTable

ModuleRefByPar<IInterfaceTable> inet::Gpsr::interfaceTable

private

Referenced by configureInterfaces(), getSelfAddress(), initialize(), and routeDatagram().

maxJitter

simtime_t inet::Gpsr::maxJitter

private

Referenced by initialize(), and scheduleBeaconTimer().

mobility

opp_component_ptr<IMobility> inet::Gpsr::mobility

private

Referenced by createBeacon(), findGreedyRoutingNextHop(), findPerimeterRoutingNextHop(), getNeighborAngle(), getPlanarNeighbors(), initialize(), and storeSelfPositionInGlobalRegistry().

neighborPositionTable

PositionTable inet::Gpsr::neighborPositionTable

private

Referenced by findGreedyRoutingNextHop(), getNeighborPosition(), getNextNeighborExpiration(), getPlanarNeighbors(), handleCrashOperation(), handleStopOperation(), initialize(), processBeacon(), and purgeNeighbors().

neighborValidityInterval

simtime_t inet::Gpsr::neighborValidityInterval

private

Referenced by getNextNeighborExpiration(), initialize(), and purgeNeighbors().

networkProtocol

ModuleRefByPar<INetfilter> inet::Gpsr::networkProtocol

private

Referenced by initialize().

outputInterface

const char* inet::Gpsr::outputInterface = nullptr

private

Referenced by initialize(), and routeDatagram().

planarizationMode

GpsrPlanarizationMode inet::Gpsr::planarizationMode = static_cast<GpsrPlanarizationMode>(-1)

private

Referenced by getPlanarNeighbors(), and initialize().

positionByteLength

int inet::Gpsr::positionByteLength = -1

private

Referenced by computeOptionLength(), createBeacon(), and initialize().

purgeNeighborsTimer

cMessage* inet::Gpsr::purgeNeighborsTimer = nullptr

private

Referenced by handleCrashOperation(), handleStopOperation(), initialize(), processSelfMessage(), schedulePurgeNeighborsTimer(), and ~Gpsr().

routingTable

ModuleRefByPar<IRoutingTable> inet::Gpsr::routingTable

private

Referenced by datagramLocalOutHook(), datagramPreRoutingHook(), getSelfAddress(), and initialize().

---

The documentation for this class was generated from the following files:

• Gpsr.h
• Gpsr.cc