private IPPacketIdentifier(ushort key, IPHeader ipHeader, SystemModule module) { Key = key; _ttl = ipHeader.TTL; Daddr = ipHeader.DestinationAddress; _module = module; }
public static IPPacketIdentifier Create(ushort key, IPHeader ipHeader, SystemModule module) { var id = new IPPacketIdentifier(key, ipHeader, module); id._timer = new Timer { Interval = 1000 }; id._timer.Elapsed += (s, e) => { id._ttl--; if (id._ttl == 0) { Log.Write("IPPacketIdentifier", "Timeout", string.Format("addr={0}, id={1}", id.Daddr.StandardFormat, id.Key)); id._timer.Stop(); module.KillIPPacketIdentifier(id); } }; return id; }
public override Handler Parse() { var header = new IPHeader(); header.VersionIHL = LoadAndScroll<Byte>(); header.TypeOfService = LoadAndScroll<Byte>(); header.TotalLength = LoadUInt16ReversingEndian(); header.Identification = LoadUInt16ReversingEndian(); header.FlagsFragmentOffset = LoadUInt16ReversingEndian(); header.TTL = LoadAndScroll<Byte>(); header.Protocol = LoadAndScroll<Byte>(); header.Crc = LoadUInt16ReversingEndian(); header.SourceAddress = LoadAndScroll<IPAddress>(); header.DestinationAddress = LoadAndScroll<IPAddress>(); Offset += header.InternetHeaderLength - 20; SetValue(IPv4HeaderProperty, header); return GetNextHandler(); }
private void HandleResponse(string deviceID, RipPreambleHeader ripPreambleHeader, RipDataHeader[] ripDataHeaderArray, IPHeader ipHeader) { foreach (RipDataHeader ripDataHeader in ripDataHeaderArray) { if (RipDatabase.ContainsKey(ripDataHeader.Network)) { RipRoute route = RipDatabase[ripDataHeader.Network]; if (ripDataHeader.Metric < route.Metric) { RipDatabase[ripDataHeader.Network].UpdateRipHeaderData(ipHeader.SourceAddress, ripDataHeader); } else if (ripDataHeader.Metric > route.Metric && ripDataHeader.NextHop == ipHeader.SourceAddress) { if (route.AcceptPotentialNewMetricOnNextSighting && route.PotentialNewMetric == ripDataHeader.Metric) { route.AcceptPotentialNewMetric(); } else { route.BeginHoldDownTime(ripDataHeader); } } route.TimeUpdated = DateTime.Now; route.RaiseEvent(RipEvent.Sighted); } else { RipRoute route = RipRoute.Create(ipHeader.SourceAddress, ripDataHeader, deviceID); route.GCCollect += (s, e) => { RipDatabase.Remove((s as RipRoute).Network); Controller.RemoveRoute(this, route); }; Log.Write("RIP", "RipDatabaseAdd", ripDataHeader.Network.StandardFormat); RipDatabase.Add(ripDataHeader.Network, route); Controller.RegisterRoute(this, route); } } }
private List<PacketData> CreatePacketData(PacketData packetData, Handler layer3Handler, Value[] parameterArray, out IPHeader baseIPHeader, out IPPacketIdentifier id) { const int ipMtu = 1500; var list = new List<PacketData>(); var ipHeader = (IPHeader)layer3Handler.Build(parameterArray); baseIPHeader = ipHeader; var headerLength = ipHeader.VersionIHL * 5; ipHeader.TotalLength = (ushort)((ipHeader.VersionIHL * 5) + packetData.Length); id = CreateIPPacketIdentifier(ipHeader); ipHeader.Identification = id.Key; var remainingData = packetData.Data; var totalTransmitCount = remainingData.Count; ushort fragmentOffset = 0; while (remainingData.Count > 0) { if (remainingData.Count + headerLength > ipMtu) { var firstFragmentSize = ipMtu - ipHeader.InternetHeaderLength; var blockCount = (int)Math.Floor((double)firstFragmentSize / 8); var copyCount = blockCount * 8; var pendingTransmitData = new List<byte>(remainingData.GetRange(0, copyCount)); remainingData = new List<byte>(remainingData.GetRange(copyCount, remainingData.Count - copyCount)); ipHeader.FlagsFragmentOffset = (ushort)((fragmentOffset >> 3) | 0x2000); Log.Write("SYSTEM", "IPFRAGMENT", fragmentOffset.ToString()); fragmentOffset += (ushort)copyCount; ipHeader.TotalLength = (ushort)((ipHeader.VersionIHL * 5) + copyCount); //++ contains MF bit //ipHeader.FlagsFragmentOffset = (ushort)(ipHeader.FlagsFragmentOffset << 3); var segmentData = PacketData.Create(pendingTransmitData); segmentData = layer3Handler.GetBytes(ipHeader, segmentData); list.Add(segmentData); } else { var pendingTransmitData = remainingData; ipHeader.FlagsFragmentOffset = (ushort)(fragmentOffset >> 3); //ipHeader.FlagsFragmentOffset = (ushort)(fragmentOffset); Log.Write("SYSTEM", "IPFRAGMENT", fragmentOffset.ToString()); //ipHeader.FlagsFragmentOffset = (ushort)(ipHeader.FlagsFragmentOffset << 3); ipHeader.TotalLength = (ushort)((ipHeader.VersionIHL * 5) + remainingData.Count); var segmentData = PacketData.Create(pendingTransmitData); segmentData = layer3Handler.GetBytes(ipHeader, segmentData); list.Add(segmentData); remainingData.Clear(); } } return list; }
private IPPacketIdentifier CreateIPPacketIdentifier(IPHeader ipHeader) { lock (_ipPacketIdentifierLock) { if (!_ipPacketIdentifierMap.ContainsKey(ipHeader.DestinationAddress)) { _ipPacketIdentifierMap[ipHeader.DestinationAddress] = new IPPacketPerDestinationIdentifier(); } IPPacketPerDestinationIdentifier destinationMap = _ipPacketIdentifierMap[ipHeader.DestinationAddress]; var key = (ushort)(destinationMap.MaxKey + 1); if (key == 65536) { key = 0; } destinationMap.MaxKey = key; IPPacketIdentifier id = IPPacketIdentifier.Create(key, ipHeader, this); destinationMap.Data.Add(key, id); return id; } }
internal void OnHelloReceive(IPHeader ipHeader, OspfHeader ospfHeader, OspfHelloHeader ospfHelloHeader) { lock (Lock) { LastSeen = DateTime.Now; Log.Write("OSPF", "NEIGHBOR", string.Format("Hello received. From: {0}, State: {1}", ospfHeader.RouterID, OspfNeighborState)); RaiseEvent(NeighborEventType.HelloReceived); if (ospfHelloHeader.Neighbor.Any(p => p == Module.RouterID)) { var tupleData = new Tuple<IPHeader, OspfHeader, Tuple<IPAddress, IPAddress>>(ipHeader, ospfHeader, new Tuple<IPAddress, IPAddress>(ospfHelloHeader.Dr, ospfHelloHeader.Bdr)); RaiseEvent(NeighborEventType.TwoWayReceived, tupleData); } else { var tupleData = new Tuple<IPHeader, OspfHeader, object>(ipHeader, ospfHeader, ospfHelloHeader); RaiseEvent(NeighborEventType.OneWayReceived, tupleData); } } }
internal void OnDBDReceive(IPHeader ipHeader, OspfHeader ospfHeader, Tuple<OspfDbdHeader, OspfLsaHeader[]> dbdHeaderData) { lock (Lock) { Log.Write("OSPF", "NEIGHBOR", string.Format("DBD received. From: {0}, State: {1}", ospfHeader.RouterID, OspfNeighborState)); var tupleData = new Tuple<IPHeader, OspfHeader, Tuple<OspfDbdHeader, OspfLsaHeader[]>>(ipHeader, ospfHeader, dbdHeaderData); var ospfDBDHeader = dbdHeaderData.Item1; var ospfLsaHeaderArray = (OspfLsaHeader[])dbdHeaderData.Item2; switch (OspfNeighborState) { case OspfNeighborState.Down: case OspfNeighborState.Attempt: return; case OspfNeighborState.Init: RaiseEvent(NeighborEventType.TwoWayReceived, new Tuple<IPHeader, OspfHeader, Tuple<IPAddress, IPAddress>>(ipHeader, ospfHeader, new Tuple<IPAddress, IPAddress>(DR, BDR))); return; case OspfNeighborState.TwoWay: return; case OspfNeighborState.ExStart: if (ospfDBDHeader.IsInitial && ospfDBDHeader.HasMore && ospfDBDHeader.IsMaster && (dbdHeaderData.Item2 == null || ospfLsaHeaderArray.Length == 0) && ospfHeader.RouterID > Module.RouterID) { Log.Write("OSPF", "NEIGHBOR---------EXSTART", "IS SLAVE TO " + ospfHeader.RouterID); LocalMSState = MasterSlaveState.Slave; _dbdPendingAck = null; DDSequenceNumber = ospfDBDHeader.SequenceNumber; LastOspfDBDSeen = ospfDBDHeader; DiscoveredOptions = ospfDBDHeader.OspfOptions; RaiseEvent(NeighborEventType.NegotiationDone); ProcessDBD(tupleData); } else if (!ospfDBDHeader.IsInitial && !ospfDBDHeader.IsMaster && DDSequenceNumber == dbdHeaderData.Item1.SequenceNumber && ospfHeader.RouterID < Module.RouterID) { Log.Write("OSPF", "NEIGHBOR---------EXSTART", "IS MASTER OF" + ospfHeader.RouterID); LocalMSState = MasterSlaveState.Master; _dbdPendingAck = null; LastOspfDBDSeen = ospfDBDHeader; DiscoveredOptions = ospfDBDHeader.OspfOptions; RaiseEvent(NeighborEventType.NegotiationDone); ProcessDBD(tupleData); } return; case OspfNeighborState.Exchange: //TODO: duplicate check? if (dbdHeaderData.Item1.IsMaster && LocalMSState == MasterSlaveState.Master) { RaiseEvent(NeighborEventType.SeqNumberMismatch, new Tuple<IPHeader, OspfHeader, Tuple<OspfDbdHeader, OspfLsaHeader[]>>(ipHeader, ospfHeader, new Tuple<OspfDbdHeader, OspfLsaHeader[]>(ospfDBDHeader, null))); return; } else if (!dbdHeaderData.Item1.IsMaster && LocalMSState == MasterSlaveState.Slave) { RaiseEvent(NeighborEventType.SeqNumberMismatch, new Tuple<IPHeader, OspfHeader, Tuple<OspfDbdHeader, OspfLsaHeader[]>>(ipHeader, ospfHeader, new Tuple<OspfDbdHeader, OspfLsaHeader[]>(ospfDBDHeader, null))); return; } else if (dbdHeaderData.Item1.IsInitial) { RaiseEvent(NeighborEventType.SeqNumberMismatch, tupleData); return; } else if (dbdHeaderData.Item1.OspfOptions != DiscoveredOptions) { RaiseEvent(NeighborEventType.SeqNumberMismatch, tupleData); return; } else if ((LocalMSState == MasterSlaveState.Master && dbdHeaderData.Item1.SequenceNumber == DDSequenceNumber) || (LocalMSState == MasterSlaveState.Slave && dbdHeaderData.Item1.SequenceNumber == DDSequenceNumber + 1)) { LastOspfDBDSeen = dbdHeaderData.Item1; ProcessDBD(tupleData); RaiseEvent(NeighborEventType.ExchangeDone); return; } else { RaiseEvent(NeighborEventType.SeqNumberMismatch, tupleData); return; } case OspfNeighborState.Loading: break; case OspfNeighborState.Full: break; default: throw new ArgumentOutOfRangeException(); } } }
private void GetSourceAndID(OspfHeader ospfHeader, IPHeader ipHeader, out IPAddress source, out IPAddress id) { switch (OspfNetworkType) { case OspfNetworkType.PointToMultiPoint: case OspfNetworkType.Broadcast: case OspfNetworkType.NBMA: source = ipHeader.SourceAddress; id = ospfHeader.RouterID; break; case OspfNetworkType.VirtualLink: source = ospfHeader.RouterID; id = ospfHeader.RouterID; break; default: case OspfNetworkType.PointToPoint: source = ospfHeader.RouterID; id = ipHeader.SourceAddress; break; } }
//private void HandleHelloMessage(IPHeader ipHeader, OspfHeader ospfHeader, OspfHelloHeader ospfHelloHeader) //{ // return; // Neighbor neighbor = NeighborMap[ospfHeader.rid] ?? Neighbor.Create(ipHeader, ospfHeader, ospfHelloHeader); // NeighborEventArgs args = NeighborEventArgs.Create(ipHeader, ospfHeader, ospfHelloHeader); // neighbor.RaiseEvent(NeighborEventType.HelloReceived, args); // if (ospfHelloHeader.neighbor.Any(p => p == RouterID)) // { // neighbor.RaiseEvent(NeighborEventType.TwoWayReceived, args); // } // if (neighbor.IsNew && IsPotentialNeighbor(ipHeader, ospfHeader, ospfHelloHeader)) // { // NeighborMap.Add(neighbor.RouterId, neighbor); // neighbor.IsNew = false; // } // else // { // Log.Write("OSPF", "HELLO", string.Format("Incompatible OSPF hello message from .", ipHeader.saddr.StandardFormat)); // } //} private bool IsPotentialNeighbor(IPHeader ipHeader, OspfHeader ospfHeader, OspfHelloHeader ospfHelloHeader) { //if (!ospfHeader.aid.Equals(Area)) //{ // return false; //} //if (ospfHelloHeader.interval != HelloInterval) //{ // return false; //} //if (ospfHelloHeader.routerdeadintvl != RouterDeadInterval) //{ // return false; //} //if (((ospfHelloHeader.Options & OspfHelloOptions.ExternalRoutingCapable) == OspfHelloOptions.ExternalRoutingCapable) == IsStub) //{ // return false; //} return true; }