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); } } } }