private void IncomingOlsrTopologyControlMessageHandler(NetSimMessage message)
{
OlsrTopologyControlMessage topMessage = (OlsrTopologyControlMessage)message;
// if own tc message
if (topMessage.Sender.Equals(this.Client.Id))
{
// drop message
return;
}
// process tc message
foreach (var mprSelector in topMessage.MultiPointRelaySelectorSet)
{
if (
!this.TopologyTable.Entries.Any(
e => e.OriginatorId.Equals(topMessage.Sender) && e.MprSelectorId.Equals(mprSelector)))
{
this.TopologyTable.AddEntry(topMessage.Sender, mprSelector);
this.IsTopologyUpdate = true;
}
}
// A node P forwards control messages only from MPRsel(P)
if (this.MultiPointRelaySelectorSet.Contains(topMessage.Sender))
{
// forward message
this.BroadcastTopologyControlMessages(topMessage);
}
}
private void IncomingAodvRouteErrorMessageHandler(NetSimMessage message)
{
AodvRouteErrorMessage errorMessage = (AodvRouteErrorMessage)message;
var aodvTable = this.Table as AodvTable;
// drop if own forwarded message
if (errorMessage.Sender.Equals(this.Client.Id))
{
return;
}
// drop every route with destination from errormessage
List <string> receivers = aodvTable?.HandleRouteMaintaince(errorMessage.UnReachableDestination);
// TODO check if the respone is not for this node . then forward
// if (!errorMessage.Receiver.Equals(Client.Id))
// {
// // forward message
// SendMessage(errorMessage);
// }
if (receivers == null)
{
return;
}
foreach (var receiver in receivers)
{
AodvRouteErrorMessage clone = (AodvRouteErrorMessage)errorMessage.Clone();
clone.Receiver = receiver;
this.SendMessage(clone);
}
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendMessage(NetSimMessage message)
{
// queue message
this.OutputQueue.Enqueue(new NetSimQueuedMessage()
{
Message = message,
});
}
/// <summary>
/// Handles the received message.
/// </summary>
/// <param name="message">The message.</param>
private void DefaultIncomingMessageHandler(NetSimMessage message)
{
// forward message if client is not reciever
if (!message.Receiver.Equals(this.Client.Id))
{
this.SendMessage(message);
}
else
{
this.Client.ReceiveData(message);
}
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendMessage(NetSimMessage message)
{
string nextHopId = this.GetRoute(message.Receiver);
if (this.IsConnectionReachable(nextHopId))
{
this.Client.Connections[nextHopId].StartTransportMessage(message, this.Client.Id, nextHopId);
}
else
{
// TODO handle not reachable connection
}
}
/// <summary>
/// Determines whether if message type is a AODV message type.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>
/// <c>true</c> if [is aodv message] [the specified message]; otherwise, <c>false</c>.
/// </returns>
private bool IsAodvMessage(NetSimMessage message)
{
List <Type> dsrTypes = new List <Type>()
{
typeof(AodvRouteReplyMessage),
typeof(AodvHelloMessage),
typeof(AodvRouteRequestMessage),
typeof(AodvRouteErrorMessage)
};
Type messageType = message.GetType();
return(dsrTypes.Any(t => t == messageType));
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendMessage(NetSimMessage message)
{
if (this.Table == null)
{
return;
}
string nextHopId = this.GetRoute(message.Receiver);
if (this.IsConnectionReachable(nextHopId))
{
this.Client.Connections[nextHopId].StartTransportMessage(message, this.Client.Id, nextHopId);
}
}
/// <summary>
/// Handles the received message.
/// </summary>
/// <param name="message">The message.</param>
private void DefaultIncomingMessageHandler(NetSimMessage message)
{
// handle the neighbour lsit update - inactive timer management
this.UpdateNeighbourList(message.Sender);
// forward message if client is not reciever
if (!message.Receiver.Equals(this.Client.Id))
{
this.SendMessage(message);
}
else
{
this.Client.ReceiveData(message);
}
}
private void IncomingDsrFrameMessageHandler(NetSimMessage message)
{
// forward message if client is not reciever
if (!message.Receiver.Equals(this.Client.Id))
{
this.SendMessage(message);
}
else
{
// unpack mesage from dsrframe
var dsrFrame = (DsrFrameMessage)message;
// forward message to client
this.Client.ReceiveData(dsrFrame.Data);
}
}
private void IncomingDsrRouteReplyMessageHandler(NetSimMessage message)
{
DsrTable dsrTable = this.Table as DsrTable;
DsrRouteReplyMessage repMessage = (DsrRouteReplyMessage)message;
// handle route caching
dsrTable?.HandleReplyRouteCaching(repMessage, this.Client.Id);
// check if the respone is for this node
if (repMessage.Receiver.Equals(this.Client.Id))
{
// save found route to table
dsrTable?.HandleResponse(repMessage);
}
else
{
// forward message
this.SendMessage(repMessage);
}
}
private void IncomingAodvHelloMessageHandler(NetSimMessage message)
{
AodvHelloMessage helloMessage = (AodvHelloMessage)message;
AodvTable aodvTable = (AodvTable)this.Table;
// handle the neighbour lsit update - inactive timer management
this.UpdateNeighbourList(helloMessage.Sender);
// search for a route for hello message sender
AodvTableEntry route = (AodvTableEntry)aodvTable.GetRouteFor(helloMessage.Sender);
// create route for neighbour if not exists
if (route == null)
{
aodvTable.AddRouteEntry(
helloMessage.Sender,
helloMessage.Sender,
1,
(AodvSequence)helloMessage.SenderSequenceNr.Clone());
}
}
private void IncomingAodvRouteReplyMessageHandler(NetSimMessage message)
{
AodvRouteReplyMessage repMessage = (AodvRouteReplyMessage)message;
var aodvTable = this.Table as AodvTable;
// handle the neighbour lsit update - inactive timer management
this.UpdateNeighbourList(repMessage.Sender);
this.UpdateNeighbourList(repMessage.LastHop);
// save found route to table
aodvTable?.HandleReplyRoute(repMessage);
// check if the respone is not for this node . then forward
if (!repMessage.Receiver.Equals(this.Client.Id))
{
// update reply message - increase hopcount and update last hop
repMessage.LastHop = this.Client.Id;
repMessage.HopCount += 1;
// forward message
this.SendMessage(repMessage);
}
}
private void IncomingDsrRouteErrorMessageHandler(NetSimMessage message)
{
DsrTable dsrTable = this.Table as DsrTable;
DsrRouteErrorMessage errorMessage = (DsrRouteErrorMessage)message;
// delete the (cached) routes defined by the error message from table
dsrTable?.HandleError(errorMessage.Sender, errorMessage.NotReachableNode);
// check if the respone is for this node
if (errorMessage.Receiver.Equals(this.Client.Id))
{
// check if error has failed message
if (errorMessage.FailedMessage != null)
{
// try to retransmit the failed message - start route discovery again
this.SendMessage(errorMessage.FailedMessage);
}
}
else
{
// forward message
this.SendMessage(errorMessage);
}
}
private void IncomingAodvRouteRequestMessageHandler(NetSimMessage message)
{
AodvTable aodvTable = (AodvTable)this.Table;
AodvRouteRequestMessage reqMessage = (AodvRouteRequestMessage)message;
// if this node was sender of request - or has already a cached version of request
if (this.IsOwnRequest(reqMessage) || this.HasCachedRequest(reqMessage))
{
// ignore message and proceed
return;
}
// add request to cache
this.AddCachedRequest(reqMessage);
// add reverse routing entry - if route doesn't exist or sequencenr is newer
aodvTable.HandleRequestReverseRouteCaching(reqMessage);
// update request message - increase hopcount and update last hop
reqMessage.LastHop = this.Client.Id;
reqMessage.HopCount += 1;
// check if message destination is current node
if (reqMessage.Receiver.Equals(this.Client.Id))
{
// send back rrep mesage the reverse way
var response = new AodvRouteReplyMessage()
{
Receiver = reqMessage.Sender,
Sender = this.Client.Id,
ReceiverSequenceNr = (AodvSequence)this.CurrentSequence.Clone(),
LastHop = this.Client.Id
};
// enqueue message for sending
this.SendMessage(response);
}
else
{
// Check if route was cached
var searchRoute = aodvTable.SearchCachedRoute(reqMessage);
if (searchRoute != null)
{
// send reply back to requester - send back rrep mesage the reverse way
var response = new AodvRouteReplyMessage()
{
Receiver = reqMessage.Sender,
Sender = searchRoute.Destination,
ReceiverSequenceNr = (AodvSequence)searchRoute.SequenceNr.Clone(),
HopCount = searchRoute.Metric,
LastHop = this.Client.Id
};
// enqueue message for sending
this.SendMessage(response);
}
else
{
// forward message to outgoing messages
this.SendMessage(reqMessage);
}
}
}
private void IncomingDsrRouteRequestMessageHandler(NetSimMessage message)
{
DsrTable dsrTable = (DsrTable)this.Table;
DsrRouteRequestMessage reqMessage = (DsrRouteRequestMessage)message;
// if duplicate
if (this.HasCachedRequest(reqMessage))
{
// ignore message and proceed
return;
}
// add request to cache
this.AddCachedRequest(reqMessage);
// add this node id to message Route
reqMessage.Nodes.Add(this.Client.Id);
// if this node was sender of request - ignore
if (this.IsOwnRequest(reqMessage))
{
return;
}
// cache route
dsrTable.HandleRequestRouteCaching(reqMessage);
// check if message destination is current node (me)
if (reqMessage.Receiver.Equals(this.Client.Id))
{
// send back rrep mesage the reverse way with found route
var response = new DsrRouteReplyMessage()
{
Receiver = reqMessage.Sender,
Sender = this.Client.Id,
Route = new List <string>(reqMessage.Nodes)
};
// enqueue message for sending
this.SendMessage(response);
return;
}
else
{
// Check if route to the end destination for request is cached
var route = this.Table.GetRouteFor(reqMessage.Receiver);
if (route != null)
{
var dsrRoute = (DsrTableEntry)route;
var newRoute = new List <string>(reqMessage.Nodes);
// remove last entry
newRoute.RemoveAt(newRoute.Count - 1);
// add cached route entries
newRoute.AddRange(dsrRoute.Route);
// send back rrep mesage the reverse way with found route
// note: sender is the orig. receiver of the req
var response = new DsrRouteReplyMessage()
{
Receiver = reqMessage.Sender,
Sender = reqMessage.Receiver,
Route = newRoute
};
// enqueue message for sending
this.SendMessage(response);
return;
}
}
// forward message to outgoing messages
this.SendMessage(reqMessage);
}
private void IncomingOlsrHelloMessageHandler(NetSimMessage message)
{
var olsrMessage = (OlsrHelloMessage)message;
// upate one hop neighbors
if (this.OneHopNeighborTable.GetEntryFor(message.Sender) == null)
{
this.OneHopNeighborTable.AddEntry(message.Sender);
this.IsHelloUpdate = true;
}
if (olsrMessage.Neighbors != null && olsrMessage.Neighbors.Any())
{
// update two hop neighbors
foreach (string twohopneighbor in olsrMessage.Neighbors)
{
// if twohop neighbor is also one hop neighbor ignore entry
if (this.OneHopNeighborTable.GetEntryFor(twohopneighbor) != null)
{
continue;
}
// if two hop neighbor is this client itself - ingore entry
if (twohopneighbor.Equals(this.Client.Id))
{
continue;
}
// search twohop neighbor entry
var twoHopBeighbor = this.TwoHopNeighborTable.GetEntryFor(twohopneighbor);
// upate two hop neighbors table
if (twoHopBeighbor == null)
{
// if neighbor not exists add it
this.TwoHopNeighborTable.AddEntry(twohopneighbor, message.Sender);
this.IsHelloUpdate = true;
}
else
{
// if neighbor exists check if sender is listed in accessthrough
if (!twoHopBeighbor.AccessibleThrough.Contains(message.Sender))
{
// if not add it to the accessable through
twoHopBeighbor.AccessibleThrough.Add(message.Sender);
this.IsHelloUpdate = true;
}
}
}
}
// if hello messages has info about multipoint relays
if (olsrMessage.MultiPointRelays != null && olsrMessage.MultiPointRelays.Any())
{
// if this client was selected as mpr by sender of this message
if (olsrMessage.MultiPointRelays.Contains(this.Client.Id))
{
if (!this.MultiPointRelaySelectorSet.Contains(olsrMessage.Sender))
{
// add sender to mpr selection set
this.MultiPointRelaySelectorSet.Add(olsrMessage.Sender);
}
}
}
}
