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::ILifecycle
virtual	~ILifecycle ()

Public Member Functions inherited from inet::INetfilter::IHook
virtual	~IHook ()

Protected Member Functions
virtual int	numInitStages () const override

void	initialize (int stage) override

void	handleMessage (cMessage *message) override

Private Member Functions
void	processSelfMessage (cMessage *message)

void	processMessage (cMessage *message)

void	scheduleBeaconTimer ()

void	processBeaconTimer ()

void	schedulePurgeNeighborsTimer ()

void	processPurgeNeighborsTimer ()

void	sendUDPPacket (UDPPacket *packet, double delay)

void	processUDPPacket (UDPPacket *packet)

GPSRBeacon *	createBeacon ()

void	sendBeacon (GPSRBeacon *beacon, double delay)

void	processBeacon (GPSRBeacon *beacon)

GPSROption *	createGpsrOption (L3Address destination, cPacket *content)

int	computeOptionLength (GPSROption *gpsrOption)

void	setGpsrOptionOnNetworkDatagram (INetworkDatagram *datagram)

void	removeGpsrOptionFromNetworkDatagram (INetworkDatagram *datagram)

GPSROption *	findGpsrOptionInNetworkDatagram (INetworkDatagram *datagram)

const GPSROption *	findGpsrOptionInNetworkDatagram (INetworkDatagram *datagram) const

GPSROption *	getGpsrOptionFromNetworkDatagram (INetworkDatagram *datagram)

const GPSROption *	getGpsrOptionFromNetworkDatagram (INetworkDatagram *datagram) const

bool	isNodeUp () const

void	configureInterfaces ()

Coord	getDestinationPosition (const L3Address &address) const

Coord	getNeighborPosition (const L3Address &address) const

double	getDestinationAngle (const L3Address &address)

double	getNeighborAngle (const L3Address &address)

std::string	getHostName () const

L3Address	getSelfAddress () const

L3Address	getSenderNeighborAddress (INetworkDatagram *datagram) const

simtime_t	getNextNeighborExpiration ()

void	purgeNeighbors ()

std::vector< L3Address >	getPlanarNeighbors ()

L3Address	getNextPlanarNeighborCounterClockwise (const L3Address &startNeighborAddress, double startNeighborAngle)

L3Address	findNextHop (INetworkDatagram *datagram, const L3Address &destination)

L3Address	findGreedyRoutingNextHop (INetworkDatagram *datagram, const L3Address &destination)

L3Address	findPerimeterRoutingNextHop (INetworkDatagram *datagram, const L3Address &destination)

Result	routeDatagram (INetworkDatagram datagram, const InterfaceEntry &outputInterfaceEntry, L3Address &nextHop)

virtual Result	datagramPreRoutingHook (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHop) 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 (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHop) override
	This is the second hook called by the network protocol before it sends a datagram to the lower layer. More...

virtual Result	datagramPostRoutingHook (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHop) override
	This is the last hook called by the network protocol before it sends a datagram to the lower layer. More...

virtual Result	datagramLocalInHook (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry) override
	This is the last hook called by the network protocol before it sends a datagram to the upper layer. More...

virtual Result	datagramLocalOutHook (INetworkDatagram datagram, const InterfaceEntry &outputInterfaceEntry, L3Address &nextHop) 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 bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

virtual void	receiveSignal (cComponent source, simsignal_t signalID, cObject obj, cObject *details) override

Static Private Member Functions
static Coord	intersectSections (Coord &begin1, Coord &end1, Coord &begin2, Coord &end2)

static double	getVectorAngle (Coord vector)

Private Attributes
GPSRPlanarizationMode	planarizationMode = (GPSRPlanarizationMode)-1

const char *	interfaces = nullptr

simtime_t	beaconInterval

simtime_t	maxJitter

simtime_t	neighborValidityInterval

cModule *	host = nullptr

NodeStatus *	nodeStatus = nullptr

IMobility *	mobility = nullptr

IL3AddressType *	addressType = nullptr

IInterfaceTable *	interfaceTable = nullptr

const char *	outputInterface = nullptr

IRoutingTable *	routingTable = nullptr

INetfilter *	networkProtocol = nullptr

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 }

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

inet::GPSR::GPSR ( )

54 {

55 }

inet::GPSR::~GPSR ( )

virtual

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

Member Function Documentation

int inet::GPSR::computeOptionLength ( GPSROption * gpsrOption )

private

Referenced by createGpsrOption().

 {
     // 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;
 }

void inet::GPSR::configureInterfaces ( )

private

Referenced by handleOperationStage(), and initialize().

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

GPSRBeacon * inet::GPSR::createBeacon ( )

private

Referenced by processBeaconTimer().

 {
     GPSRBeacon *beacon = new GPSRBeacon("GPSRBeacon");
     beacon->setAddress(getSelfAddress());
     beacon->setPosition(mobility->getCurrentPosition());
     beacon->setByteLength(getSelfAddress().getAddressType()->getAddressByteLength() + positionByteLength);
     return beacon;
 }

GPSROption * inet::GPSR::createGpsrOption	(	L3Address	destination,
		cPacket *	content
	)

private

Referenced by setGpsrOptionOnNetworkDatagram().

 {
     GPSROption *gpsrOption = new GPSROption();
     gpsrOption->setRoutingMode(GPSR_GREEDY_ROUTING);
     // KLUDGE: implement position registry protocol
     gpsrOption->setDestinationPosition(getDestinationPosition(destination));
     gpsrOption->setLength(computeOptionLength(gpsrOption));
     return gpsrOption;
 }

virtual Result inet::GPSR::datagramForwardHook	(	INetworkDatagram *	datagram,
		const InterfaceEntry *	inputInterfaceEntry,
		const InterfaceEntry *&	outputInterfaceEntry,
		L3Address &	nextHopAddress
	)

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.

158 { return ACCEPT; }

inet::INetfilter::IHook::ACCEPT

allows the datagram to pass to the next hook

Definition: INetfilter.h:50

virtual Result inet::GPSR::datagramLocalInHook	(	INetworkDatagram *	datagram,
		const InterfaceEntry *	inputInterfaceEntry
	)

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.

160 { return ACCEPT; }

inet::INetfilter::IHook::ACCEPT

allows the datagram to pass to the next hook

Definition: INetfilter.h:50

INetfilter::IHook::Result inet::GPSR::datagramLocalOutHook	(	INetworkDatagram *	datagram,
		const InterfaceEntry *&	outputInterfaceEntry,
		L3Address &	nextHopAddress
	)

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 outputInterfaceEntry is a nullptr. After this is done

Implements inet::INetfilter::IHook.

 {
     Enter_Method("datagramLocalOutHook");
     const L3Address& destination = datagram->getDestinationAddress();
     if (destination.isMulticast() || destination.isBroadcast() || routingTable->isLocalAddress(destination))
         return ACCEPT;
     else {
         setGpsrOptionOnNetworkDatagram(datagram);
         return routeDatagram(datagram, outputInterfaceEntry, nextHop);
     }
 }

virtual Result inet::GPSR::datagramPostRoutingHook	(	INetworkDatagram *	datagram,
		const InterfaceEntry *	inputInterfaceEntry,
		const InterfaceEntry *&	outputInterfaceEntry,
		L3Address &	nextHopAddress
	)

inlineoverrideprivatevirtual

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

Implements inet::INetfilter::IHook.

159 { return ACCEPT; }

inet::INetfilter::IHook::ACCEPT

allows the datagram to pass to the next hook

Definition: INetfilter.h:50

INetfilter::IHook::Result inet::GPSR::datagramPreRoutingHook	(	INetworkDatagram *	datagram,
		const InterfaceEntry *	inputInterfaceEntry,
		const InterfaceEntry *&	outputInterfaceEntry,
		L3Address &	nextHopAddress
	)

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 outputInterfaceEntry is nullptr.

Implements inet::INetfilter::IHook.

 {
     Enter_Method("datagramPreRoutingHook");
     const L3Address& destination = datagram->getDestinationAddress();
     if (destination.isMulticast() || destination.isBroadcast() || routingTable->isLocalAddress(destination))
         return ACCEPT;
     else
         return routeDatagram(datagram, outputInterfaceEntry, nextHop);
 }

GPSROption * inet::GPSR::findGpsrOptionInNetworkDatagram ( INetworkDatagram * datagram )

private

Referenced by getGpsrOptionFromNetworkDatagram().

 {
     cPacket *networkPacket = check_and_cast<cPacket *>(datagram);
     GPSROption *gpsrOption = nullptr;
 
 #ifdef WITH_IPv4
     if (dynamic_cast<IPv4Datagram *>(networkPacket)) {
         IPv4Datagram *dgram = static_cast<IPv4Datagram *>(networkPacket);
         gpsrOption = check_and_cast_nullable<GPSROption *>(dgram->findOptionByType(IPOPTION_TLV_GPSR));
     }
     else
 #endif
 #ifdef WITH_IPv6
     if (dynamic_cast<IPv6Datagram *>(networkPacket)) {
         IPv6Datagram *dgram = static_cast<IPv6Datagram *>(networkPacket);
         IPv6HopByHopOptionsHeader *hdr = check_and_cast_nullable<IPv6HopByHopOptionsHeader *>(dgram->findExtensionHeaderByType(IP_PROT_IPv6EXT_HOP));
         if (hdr != nullptr) {
             int i = (hdr->getTlvOptions().findByType(IPv6TLVOPTION_TLV_GPSR));
             if (i >= 0)
                 gpsrOption = check_and_cast_nullable<GPSROption *>(&(hdr->getTlvOptions().at(i)));
         }
     }
     else
 #endif
 #ifdef WITH_GENERIC
     if (dynamic_cast<GenericDatagram *>(networkPacket)) {
         GenericDatagram *dgram = static_cast<GenericDatagram *>(networkPacket);
         int i = (dgram->getTlvOptions().findByType(GENERIC_TLVOPTION_TLV_GPSR));
         if (i >= 0)
             gpsrOption = check_and_cast_nullable<GPSROption *>(&(dgram->getTlvOptions().at(i)));
     }
     else
 #endif
     {
     }
     return gpsrOption;
 }

const GPSROption* inet::GPSR::findGpsrOptionInNetworkDatagram ( INetworkDatagram * datagram ) const

inlineprivate

Referenced by findGpsrOptionInNetworkDatagram().

117 { return const_cast<GPSR *>(this)->findGpsrOptionInNetworkDatagram(datagram); }

inet::GPSR::findGpsrOptionInNetworkDatagram

GPSROption * findGpsrOptionInNetworkDatagram(INetworkDatagram *datagram)

Definition: GPSR.cc:643

inet::GPSR::GPSR

GPSR()

Definition: GPSR.cc:53

L3Address inet::GPSR::findGreedyRoutingNextHop	(	INetworkDatagram *	datagram,
		const L3Address &	destination
	)

private

Referenced by findNextHop(), and findPerimeterRoutingNextHop().

 {
     EV_DEBUG << "Finding next hop using greedy routing: destination = " << destination << endl;
     GPSROption *gpsrOption = getGpsrOptionFromNetworkDatagram(datagram);
     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;
         gpsrOption->setRoutingMode(GPSR_PERIMETER_ROUTING);
         gpsrOption->setPerimeterRoutingStartPosition(selfPosition);
         gpsrOption->setCurrentFaceFirstSenderAddress(selfAddress);
         gpsrOption->setCurrentFaceFirstReceiverAddress(L3Address());
         return findPerimeterRoutingNextHop(datagram, destination);
     }
     else
         return bestNeighbor;
 }

L3Address inet::GPSR::findNextHop	(	INetworkDatagram *	datagram,
		const L3Address &	destination
	)

private

Referenced by routeDatagram().

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

L3Address inet::GPSR::findPerimeterRoutingNextHop	(	INetworkDatagram *	datagram,
		const L3Address &	destination
	)

private

Referenced by findGreedyRoutingNextHop(), and findNextHop().

 {
     EV_DEBUG << "Finding next hop using perimeter routing: destination = " << destination << endl;
     GPSROption *gpsrOption = getGpsrOptionFromNetworkDatagram(datagram);
     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;
         gpsrOption->setRoutingMode(GPSR_GREEDY_ROUTING);
         gpsrOption->setPerimeterRoutingStartPosition(Coord());
         gpsrOption->setPerimeterRoutingForwardPosition(Coord());
         return findGreedyRoutingNextHop(datagram, destination);
     }
     else {
         L3Address& firstSenderAddress = gpsrOption->getCurrentFaceFirstSenderAddress();
         L3Address& firstReceiverAddress = gpsrOption->getCurrentFaceFirstReceiverAddress();
         L3Address nextNeighborAddress = getSenderNeighborAddress(datagram);
         bool hasIntersection;
         do {
             if (nextNeighborAddress.isUnspecified())
                 nextNeighborAddress = getNextPlanarNeighborCounterClockwise(nextNeighborAddress, getDestinationAngle(destination));
             else
                 nextNeighborAddress = getNextPlanarNeighborCounterClockwise(nextNeighborAddress, getNeighborAngle(nextNeighborAddress));
             if (nextNeighborAddress.isUnspecified())
                 break;
             EV_DEBUG << "Intersecting towards next hop: nextNeighbor = " << nextNeighborAddress << ", firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
             Coord nextNeighborPosition = getNeighborPosition(nextNeighborAddress);
             Coord intersection = intersectSections(perimeterRoutingStartPosition, destinationPosition, selfPosition, nextNeighborPosition);
             hasIntersection = !std::isnan(intersection.x);
             if (hasIntersection) {
                 EV_DEBUG << "Edge to next hop intersects: intersection = " << intersection << ", nextNeighbor = " << nextNeighborAddress << ", firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
                 gpsrOption->setCurrentFaceFirstSenderAddress(selfAddress);
                 gpsrOption->setCurrentFaceFirstReceiverAddress(L3Address());
             }
         } while (hasIntersection);
         if (firstSenderAddress == selfAddress && firstReceiverAddress == nextNeighborAddress) {
             EV_DEBUG << "End of perimeter reached: firstSender = " << firstSenderAddress << ", firstReceiver = " << firstReceiverAddress << ", destination = " << destination << endl;
             return L3Address();
         }
         else {
             if (gpsrOption->getCurrentFaceFirstReceiverAddress().isUnspecified())
                 gpsrOption->setCurrentFaceFirstReceiverAddress(nextNeighborAddress);
             return nextNeighborAddress;
         }
     }
 }

double inet::GPSR::getDestinationAngle ( const L3Address & address )

private

Referenced by findPerimeterRoutingNextHop().

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

Coord inet::GPSR::getDestinationPosition ( const L3Address & address ) const

private

Referenced by createGpsrOption(), and getDestinationAngle().

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

GPSROption * inet::GPSR::getGpsrOptionFromNetworkDatagram ( INetworkDatagram * datagram )

private

Referenced by findGreedyRoutingNextHop(), findNextHop(), findPerimeterRoutingNextHop(), getSenderNeighborAddress(), and routeDatagram().

 {
     GPSROption *gpsrOption = findGpsrOptionInNetworkDatagram(datagram);
     if (gpsrOption == nullptr)
         throw cRuntimeError("GPSR option not found in datagram!");
     return gpsrOption;
 }

const GPSROption* inet::GPSR::getGpsrOptionFromNetworkDatagram ( INetworkDatagram * datagram ) const

inlineprivate

Referenced by getGpsrOptionFromNetworkDatagram().

121 { return const_cast<GPSR *>(this)->getGpsrOptionFromNetworkDatagram(datagram); }

inet::GPSR::getGpsrOptionFromNetworkDatagram

GPSROption * getGpsrOptionFromNetworkDatagram(INetworkDatagram *datagram)

Definition: GPSR.cc:681

inet::GPSR::GPSR

GPSR()

Definition: GPSR.cc:53

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

private

 {
     return host->getFullName();
 }

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

private

Referenced by findPerimeterRoutingNextHop(), and getNextPlanarNeighborCounterClockwise().

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

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

private

Referenced by findPerimeterRoutingNextHop(), and getNeighborAngle().

 {
     return neighborPositionTable.getPosition(address);
 }

simtime_t inet::GPSR::getNextNeighborExpiration ( )

private

Referenced by schedulePurgeNeighborsTimer().

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

L3Address inet::GPSR::getNextPlanarNeighborCounterClockwise	(	const L3Address &	startNeighborAddress,
		double	startNeighborAngle
	)

private

Referenced by findPerimeterRoutingNextHop().

 {
     EV_DEBUG << "Finding next planar neighbor (counter clockwise): startAddress = " << startNeighborAddress << ", startAngle = " << startNeighborAngle << endl;
     L3Address bestNeighborAddress = startNeighborAddress;
     double bestNeighborAngleDifference = 2 * M_PI;
     std::vector<L3Address> neighborAddresses = getPlanarNeighbors();
     for (auto & neighborAddress : neighborAddresses) {
         double neighborAngle = getNeighborAngle(neighborAddress);
         double neighborAngleDifference = neighborAngle - startNeighborAngle;
         if (neighborAngleDifference < 0)
             neighborAngleDifference += 2 * M_PI;
         EV_DEBUG << "Trying next planar neighbor (counter clockwise): address = " << neighborAddress << ", angle = " << neighborAngle << endl;
         if (neighborAngleDifference != 0 && neighborAngleDifference < bestNeighborAngleDifference) {
             bestNeighborAngleDifference = neighborAngleDifference;
             bestNeighborAddress = neighborAddress;
         }
     }
     return bestNeighborAddress;
 }

std::vector< L3Address > inet::GPSR::getPlanarNeighbors ( )

private

Referenced by getNextPlanarNeighborCounterClockwise().

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

L3Address inet::GPSR::getSelfAddress ( ) const

private

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

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

L3Address inet::GPSR::getSenderNeighborAddress ( INetworkDatagram * datagram ) const

private

Referenced by findPerimeterRoutingNextHop().

 {
     const GPSROption *gpsrOption = getGpsrOptionFromNetworkDatagram(datagram);
     return gpsrOption->getSenderAddress();
 }

double inet::GPSR::getVectorAngle ( Coord vector )

staticprivate

Referenced by getDestinationAngle(), and getNeighborAngle().

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

void inet::GPSR::handleMessage ( cMessage * message )

overrideprotected

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

bool inet::GPSR::handleOperationStage	(	LifecycleOperation *	operation,
		int	stage,
		IDoneCallback *	doneCallback
	)

overrideprivatevirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

 {
     Enter_Method_Silent();
     if (dynamic_cast<NodeStartOperation *>(operation)) {
         if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER)
             configureInterfaces();
     }
     else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
         if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
             // TODO: send a beacon to remove ourself from peers neighbor position table
             neighborPositionTable.clear();
             cancelEvent(beaconTimer);
             cancelEvent(purgeNeighborsTimer);
         }
     }
     else if (dynamic_cast<NodeCrashOperation *>(operation)) {
         if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
             neighborPositionTable.clear();
             cancelEvent(beaconTimer);
             cancelEvent(purgeNeighborsTimer);
         }
     }
     else
         throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
     return true;
 }

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

overrideprotected

 {
     cSimpleModule::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         // GPSR parameters
         planarizationMode = (GPSRPlanarizationMode)(int)par("planarizationMode");
         interfaces = par("interfaces");
         beaconInterval = par("beaconInterval");
         maxJitter = par("maxJitter");
         neighborValidityInterval = par("neighborValidityInterval");
         // context
         host = getContainingNode(this);
         nodeStatus = dynamic_cast<NodeStatus *>(host->getSubmodule("status"));
         interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         outputInterface = par("outputInterface");
         mobility = check_and_cast<IMobility *>(host->getSubmodule("mobility"));
         routingTable = getModuleFromPar<IRoutingTable>(par("routingTableModule"), this);
         networkProtocol = getModuleFromPar<INetfilter>(par("networkProtocolModule"), this);
         // internal
         beaconTimer = new cMessage("BeaconTimer");
         purgeNeighborsTimer = new cMessage("PurgeNeighborsTimer");
 
         // packet size
         positionByteLength = par("positionByteLength");
     }
     else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
         IPSocket socket(gate("ipOut"));
         socket.registerProtocol(IP_PROT_MANET);
 
         globalPositionTable.clear();
         host->subscribe(NF_LINK_BREAK, this);
         addressType = getSelfAddress().getAddressType();
         networkProtocol->registerHook(0, this);
         if (isNodeUp()) {
             configureInterfaces();
             scheduleBeaconTimer();
             schedulePurgeNeighborsTimer();
         }
         WATCH(neighborPositionTable);
     }
 }

Coord inet::GPSR::intersectSections	(	Coord &	begin1,
		Coord &	end1,
		Coord &	begin2,
		Coord &	end2
	)

staticprivate

Referenced by findPerimeterRoutingNextHop().

 {
     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 (x1 < x && x < x2 && x3 < x && x < x4 && y1 < y && y < y2 && y3 < y && y < y4)
         return Coord(x, y, 0);
     else
         return Coord(NaN, NaN, NaN);
 }

bool inet::GPSR::isNodeUp ( ) const

private

Referenced by initialize().

 {
     return !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
 }

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

inlineoverrideprotectedvirtual

83 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::GPSR::processBeacon ( GPSRBeacon * beacon )

private

Referenced by processUDPPacket().

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

void inet::GPSR::processBeaconTimer ( )

private

Referenced by processSelfMessage().

 {
     EV_DEBUG << "Processing beacon timer" << endl;
     L3Address selfAddress = getSelfAddress();
     if (!selfAddress.isUnspecified()) {
         sendBeacon(createBeacon(), uniform(0, maxJitter).dbl());
         // KLUDGE: implement position registry protocol
         globalPositionTable.setPosition(selfAddress, mobility->getCurrentPosition());
     }
     scheduleBeaconTimer();
     schedulePurgeNeighborsTimer();
 }

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

private

Referenced by handleMessage().

 {
     if (dynamic_cast<UDPPacket *>(message))
         processUDPPacket(static_cast<UDPPacket *>(message));
     else
         throw cRuntimeError("Unknown message");
 }

void inet::GPSR::processPurgeNeighborsTimer ( )

private

Referenced by processSelfMessage().

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

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

private

Referenced by handleMessage().

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

void inet::GPSR::processUDPPacket ( UDPPacket * packet )

private

Referenced by processMessage().

 {
     cPacket *encapsulatedPacket = packet->decapsulate();
     if (dynamic_cast<GPSRBeacon *>(encapsulatedPacket))
         processBeacon(static_cast<GPSRBeacon *>(encapsulatedPacket));
     else
         throw cRuntimeError("Unknown UDP packet");
     delete packet;
 }

void inet::GPSR::purgeNeighbors ( )

private

Referenced by processPurgeNeighborsTimer().

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

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

overrideprivatevirtual

 {
     Enter_Method("receiveChangeNotification");
     if (signalID == NF_LINK_BREAK) {
         EV_WARN << "Received link break" << endl;
         // TODO: shall we remove the neighbor?
     }
 }

void inet::GPSR::removeGpsrOptionFromNetworkDatagram ( INetworkDatagram * datagram )

private

INetfilter::IHook::Result inet::GPSR::routeDatagram	(	INetworkDatagram *	datagram,
		const InterfaceEntry *&	outputInterfaceEntry,
		L3Address &	nextHop
	)

private

Referenced by datagramLocalOutHook(), and datagramPreRoutingHook().

 {
     const L3Address& source = datagram->getSourceAddress();
     const L3Address& destination = datagram->getDestinationAddress();
     EV_INFO << "Finding next hop: source = " << source << ", destination = " << destination << endl;
     nextHop = findNextHop(datagram, destination);
     if (nextHop.isUnspecified()) {
         EV_WARN << "No next hop found, dropping packet: source = " << source << ", destination = " << destination << endl;
         return DROP;
     }
     else {
         EV_INFO << "Next hop found: source = " << source << ", destination = " << destination << ", nextHop: " << nextHop << endl;
         GPSROption *gpsrOption = getGpsrOptionFromNetworkDatagram(datagram);
         gpsrOption->setSenderAddress(getSelfAddress());
         outputInterfaceEntry = interfaceTable->getInterfaceByName(outputInterface);
         ASSERT(outputInterfaceEntry);
         return ACCEPT;
     }
 }

void inet::GPSR::scheduleBeaconTimer ( )

private

Referenced by initialize(), and processBeaconTimer().

 {
     EV_DEBUG << "Scheduling beacon timer" << endl;
     scheduleAt(simTime() + beaconInterval, beaconTimer);
 }

void inet::GPSR::schedulePurgeNeighborsTimer ( )

private

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

 {
     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) {
                 cancelEvent(purgeNeighborsTimer);
                 scheduleAt(nextExpiration, purgeNeighborsTimer);
             }
         }
     }
 }

void inet::GPSR::sendBeacon	(	GPSRBeacon *	beacon,
		double	delay
	)

private

Referenced by processBeaconTimer().

 {
     EV_INFO << "Sending beacon: address = " << beacon->getAddress() << ", position = " << beacon->getPosition() << endl;
     INetworkProtocolControlInfo *networkProtocolControlInfo = addressType->createNetworkProtocolControlInfo();
     networkProtocolControlInfo->setTransportProtocol(IP_PROT_MANET);
     networkProtocolControlInfo->setHopLimit(255);
     networkProtocolControlInfo->setDestinationAddress(addressType->getLinkLocalManetRoutersMulticastAddress());
     networkProtocolControlInfo->setSourceAddress(getSelfAddress());
     UDPPacket *udpPacket = new UDPPacket(beacon->getName());
     udpPacket->encapsulate(beacon);
     udpPacket->setSourcePort(GPSR_UDP_PORT);
     udpPacket->setDestinationPort(GPSR_UDP_PORT);
     udpPacket->setControlInfo(dynamic_cast<cObject *>(networkProtocolControlInfo));
     sendUDPPacket(udpPacket, delay);
 }

void inet::GPSR::sendUDPPacket	(	UDPPacket *	packet,
		double	delay
	)

private

Referenced by sendBeacon().

 {
     if (delay == 0)
         send(packet, "ipOut");
     else
         sendDelayed(packet, delay, "ipOut");
 }

void inet::GPSR::setGpsrOptionOnNetworkDatagram ( INetworkDatagram * datagram )

private

Referenced by datagramLocalOutHook().

 {
     cPacket *networkPacket = check_and_cast<cPacket *>(datagram);
     GPSROption *gpsrOption = createGpsrOption(datagram->getDestinationAddress(), networkPacket->getEncapsulatedPacket());
 #ifdef WITH_IPv4
     if (dynamic_cast<IPv4Datagram *>(networkPacket)) {
         gpsrOption->setType(IPOPTION_TLV_GPSR);
         IPv4Datagram *dgram = static_cast<IPv4Datagram *>(networkPacket);
         int oldHlen = dgram->calculateHeaderByteLength();
         ASSERT(dgram->getHeaderLength() == oldHlen);
         dgram->addOption(gpsrOption);
         int newHlen = dgram->calculateHeaderByteLength();
         dgram->setHeaderLength(newHlen);
         dgram->addByteLength(newHlen - oldHlen);
         dgram->setTotalLengthField(dgram->getTotalLengthField() + newHlen - oldHlen);
     }
     else
 #endif
 #ifdef WITH_IPv6
     if (dynamic_cast<IPv6Datagram *>(networkPacket)) {
         gpsrOption->setType(IPv6TLVOPTION_TLV_GPSR);
         IPv6Datagram *dgram = static_cast<IPv6Datagram *>(networkPacket);
         int oldHlen = dgram->calculateHeaderByteLength();
         IPv6HopByHopOptionsHeader *hdr = check_and_cast_nullable<IPv6HopByHopOptionsHeader *>(dgram->findExtensionHeaderByType(IP_PROT_IPv6EXT_HOP));
         if (hdr == nullptr) {
             hdr = new IPv6HopByHopOptionsHeader();
             hdr->setByteLength(8);
             dgram->addExtensionHeader(hdr);
         }
         hdr->getTlvOptions().add(gpsrOption);
         hdr->setByteLength(utils::roundUp(2 + hdr->getTlvOptions().getLength(), 8));
         int newHlen = dgram->calculateHeaderByteLength();
         dgram->addByteLength(newHlen - oldHlen);
     }
     else
 #endif
 #ifdef WITH_GENERIC
     if (dynamic_cast<GenericDatagram *>(networkPacket)) {
         gpsrOption->setType(GENERIC_TLVOPTION_TLV_GPSR);
         GenericDatagram *dgram = static_cast<GenericDatagram *>(networkPacket);
         int oldHlen = dgram->getTlvOptions().getLength();
         dgram->getTlvOptions().add(gpsrOption);
         int newHlen = dgram->getTlvOptions().getLength();
         dgram->addByteLength(newHlen - oldHlen);
     }
     else
 #endif
     {
     }
 }