private static void CompareFrame(XElement frame, Packet packet)
{
foreach (var field in frame.Fields())
{
switch (field.Name())
{
// case "frame.time":
// string fieldShow = field.Show();
// if (fieldShow == "Not representable")
// break;
// fieldShow = fieldShow.Substring(0, fieldShow.Length - 2);
// DateTime fieldTimestamp = fieldShow[4] == ' '
// ? DateTime.ParseExact(fieldShow, "MMM d, yyyy HH:mm:ss.fffffff", CultureInfo.InvariantCulture)
// : DateTime.ParseExact(fieldShow, "MMM dd, yyyy HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
// MoreAssert.IsInRange(fieldTimestamp.AddSeconds(-2), fieldTimestamp.AddSeconds(2), packet.Timestamp, "Timestamp");
// break;
case "frame.time_epoch":
double timeEpoch = double.Parse(field.Show(), CultureInfo.InvariantCulture);
// TODO: Remove this condition when https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=11744 is fixed.
if (timeEpoch >= int.MinValue)
{
DateTime fieldTimestamp = new DateTime(1970, 1, 1).AddSeconds(timeEpoch);
MoreAssert.IsInRange(fieldTimestamp.AddMilliseconds(-1), fieldTimestamp.AddMilliseconds(1), packet.Timestamp.ToUniversalTime(),
"Timestamp");
}
break;
case "frame.cap_len":
field.AssertShowDecimal(packet.Length);
break;
}
}
}
public void GetPacketTest()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPackets = 10;
Packet expectedPacket = _random.NextEthernetPacket(100, SourceMac, DestinationMac);
using (PacketCommunicator communicator = OpenOfflineDevice(NumPackets, expectedPacket))
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
PacketCommunicatorReceiveResult result;
Packet actualPacket;
for (int i = 0; i != NumPackets; ++i)
{
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, actualPacket);
MoreAssert.IsInRange(expectedPacket.Timestamp.AddSeconds(-0.05), expectedPacket.Timestamp.AddSeconds(0.05),
actualPacket.Timestamp);
}
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Eof, result);
Assert.IsNull(actualPacket);
}
}
public void SetSamplingMethodFirstAfterIntervalTest()
{
const int NumPackets = 10;
Packet expectedPacket = _random.NextEthernetPacket(100);
using (PacketCommunicator communicator = OpenOfflineDevice(NumPackets, expectedPacket, TimeSpan.FromSeconds(1)))
{
communicator.SetSamplingMethod(new SamplingMethodFirstAfterInterval(TimeSpan.FromSeconds(2)));
PacketCommunicatorReceiveResult result;
Packet packet;
for (int i = 0; i != 5; ++i)
{
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, packet);
DateTime expectedTimestamp = expectedPacket.Timestamp.AddSeconds(i * 2);
MoreAssert.IsInRange(expectedTimestamp.AddSeconds(-0.01), expectedTimestamp.AddSeconds(0.01), packet.Timestamp);
}
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Eof, result);
Assert.IsNull(packet);
}
}
public void DumpWithoutDeviceTest()
{
string filename = Path.GetTempPath() + @"dump.pcap";
Packet expectedPacket = PacketBuilder.Build(DateTime.Now,
new EthernetLayer
{
Source = new MacAddress(1),
Destination = new MacAddress(2),
EtherType = EthernetType.QInQ,
},
new PayloadLayer
{
Data = new Datagram(new byte[] { 1, 2, 3 })
});
PacketDumpFile.Dump(filename, DataLinkKind.Ethernet, PacketDevice.DefaultSnapshotLength,
new[] { expectedPacket });
using (PacketCommunicator communicator = new OfflinePacketDevice(filename).Open())
{
Packet actualPacket;
PacketCommunicatorReceiveResult result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, actualPacket);
MoreAssert.IsInRange(expectedPacket.Timestamp.AddMicroseconds(-2), expectedPacket.Timestamp.AddMicroseconds(1), actualPacket.Timestamp);
}
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private static void TestOpenMultipleTimes(int numTimes, string filename)
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPackets = 10;
Packet expectedPacket = _random.NextEthernetPacket(100, SourceMac, DestinationMac);
PacketDevice device = GetOfflineDevice(NumPackets, expectedPacket, TimeSpan.Zero, Path.GetTempPath() + @"dump.pcap", Path.GetTempPath() + filename);
for (int j = 0; j != numTimes; ++j)
{
using (PacketCommunicator communicator = device.Open())
{
PacketCommunicatorReceiveResult result;
Packet actualPacket;
for (int i = 0; i != NumPackets; ++i)
{
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, actualPacket);
MoreAssert.IsInRange(expectedPacket.Timestamp.AddSeconds(-0.05), expectedPacket.Timestamp.AddSeconds(0.05),
actualPacket.Timestamp);
}
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Eof, result);
Assert.IsNull(actualPacket);
}
}
}
public void OpenOfflineMultipleTimes()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPackets = 10;
Packet expectedPacket = _random.NextEthernetPacket(100, SourceMac, DestinationMac);
PacketDevice device = GetOfflineDevice(NumPackets, expectedPacket);
// TODO: Fix so we can go beyond 509.
// See http://www.winpcap.org/pipermail/winpcap-bugs/2012-December/001547.html
for (int j = 0; j != 100; ++j)
{
using (PacketCommunicator communicator = device.Open())
{
PacketCommunicatorReceiveResult result;
Packet actualPacket;
for (int i = 0; i != NumPackets; ++i)
{
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, actualPacket);
MoreAssert.IsInRange(expectedPacket.Timestamp.AddSeconds(-0.05), expectedPacket.Timestamp.AddSeconds(0.05),
actualPacket.Timestamp);
}
result = communicator.ReceivePacket(out actualPacket);
Assert.AreEqual(PacketCommunicatorReceiveResult.Eof, result);
Assert.IsNull(actualPacket);
}
}
}
private static void CompareFrame(XElement frame, Packet packet)
{
foreach (var field in frame.Fields())
{
switch (field.Name())
{
// case "frame.time":
// string fieldShow = field.Show();
// if (fieldShow == "Not representable")
// break;
// fieldShow = fieldShow.Substring(0, fieldShow.Length - 2);
// DateTime fieldTimestamp = fieldShow[4] == ' '
// ? DateTime.ParseExact(fieldShow, "MMM d, yyyy HH:mm:ss.fffffff", CultureInfo.InvariantCulture)
// : DateTime.ParseExact(fieldShow, "MMM dd, yyyy HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
// MoreAssert.IsInRange(fieldTimestamp.AddSeconds(-2), fieldTimestamp.AddSeconds(2), packet.Timestamp, "Timestamp");
// break;
case "frame.time_epoch":
double timeEpoch = double.Parse(field.Show());
DateTime fieldTimestamp = new DateTime(1970, 1, 1).AddSeconds(timeEpoch);
MoreAssert.IsInRange(fieldTimestamp.AddMilliseconds(-1), fieldTimestamp.AddMilliseconds(1), packet.Timestamp.ToUniversalTime(), "Timestamp");
break;
case "frame.cap_len":
field.AssertShowDecimal(packet.Length);
break;
}
}
}
private static void TestReceivePacketsEnumerable(int numPacketsToSend, int numPacketsToWait, int numPacketsToBreakLoop, double secondsToWait,
int packetSize, int expectedNumPackets, double expectedMinSeconds, double expectedMaxSeconds)
{
string testDescription = "NumPacketsToSend=" + numPacketsToSend + ". NumPacketsToWait=" + numPacketsToWait +
". NumPacketsToBreakLoop=" + numPacketsToBreakLoop + ". SecondsToWait=" +
secondsToWait + ". PacketSize=" + packetSize;
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
Packet sentPacket = _random.NextEthernetPacket(packetSize, SourceMac, DestinationMac);
for (int i = 0; i != numPacketsToSend; ++i)
{
communicator.SendPacket(sentPacket);
}
int actualPacketsReceived = 0;
Thread thread = new Thread(delegate()
{
if (numPacketsToBreakLoop == 0)
{
communicator.Break();
}
IEnumerable <Packet> packets = numPacketsToWait == -1
? communicator.ReceivePackets()
: communicator.ReceivePackets(numPacketsToWait);
foreach (Packet packet in packets)
{
Assert.AreEqual(sentPacket, packet);
++actualPacketsReceived;
if (actualPacketsReceived == numPacketsToBreakLoop)
{
break;
}
}
});
DateTime startWaiting = DateTime.Now;
thread.Start();
if (!thread.Join(TimeSpan.FromSeconds(secondsToWait)))
{
thread.Abort();
}
DateTime finishedWaiting = DateTime.Now;
Assert.AreEqual(expectedNumPackets, actualPacketsReceived, testDescription);
MoreAssert.IsInRange(expectedMinSeconds, expectedMaxSeconds, (finishedWaiting - startWaiting).TotalSeconds, testDescription);
}
}
private static void TestGetStatistics(string sourceMac, string destinationMac, int numPacketsToSend, int numStatisticsToGather, int numStatisticsToBreakLoop, double secondsToWait, int packetSize,
PacketCommunicatorReceiveResult expectedResult, int expectedNumStatistics, int expectedNumPackets, double expectedMinSeconds, double expectedMaxSeconds)
{
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.Mode = PacketCommunicatorMode.Statistics;
communicator.SetFilter("ether src " + sourceMac + " and ether dst " + destinationMac);
Packet sentPacket = _random.NextEthernetPacket(packetSize, sourceMac, destinationMac);
PacketCommunicatorReceiveResult result = PacketCommunicatorReceiveResult.None;
int numStatisticsGot = 0;
ulong totalPackets = 0;
ulong totalBytes = 0;
for (int i = 0; i != numPacketsToSend; ++i)
{
communicator.SendPacket(sentPacket);
}
if (numStatisticsToBreakLoop == 0)
{
communicator.Break();
}
Thread thread = new Thread(delegate()
{
result = communicator.ReceiveStatistics(numStatisticsToGather,
delegate(PacketSampleStatistics statistics)
{
Assert.IsNotNull(statistics.ToString());
totalPackets += statistics.AcceptedPackets;
totalBytes += statistics.AcceptedBytes;
++numStatisticsGot;
if (numStatisticsGot >= numStatisticsToBreakLoop)
{
communicator.Break();
}
});
});
DateTime startWaiting = DateTime.Now;
thread.Start();
if (!thread.Join(TimeSpan.FromSeconds(secondsToWait)))
{
thread.Abort();
}
DateTime finishedWaiting = DateTime.Now;
Assert.AreEqual(expectedResult, result, "Result");
Assert.AreEqual(expectedNumStatistics, numStatisticsGot, "NumStatistics");
Assert.AreEqual((ulong)expectedNumPackets, totalPackets, "NumPackets");
// Todo check byte statistics. See http://www.winpcap.org/pipermail/winpcap-users/2015-February/004931.html
// Assert.AreEqual((ulong)(numPacketsToSend * sentPacket.Length), totalBytes, "NumBytes");
MoreAssert.IsInRange(expectedMinSeconds, expectedMaxSeconds, (finishedWaiting - startWaiting).TotalSeconds);
}
}
public void Handle(Packet packet)
{
Assert.AreEqual(_expectedPacket, packet);
MoreAssert.IsInRange(_expectedMinTimestamp, _expectedMaxTimestamp, packet.Timestamp);
++_numPacketsHandled;
if (NumPacketsHandled >= _numPacketsToBreakLoop)
{
_communicator.Break();
}
}
private void ValidateExtensionHeaderUnnamedField(IpV6ExtensionHeader header, XElement headerField, ref int optionsIndex)
{
IpV6ExtensionHeaderOptions headerOptions = header as IpV6ExtensionHeaderOptions;
string[] headerFieldShowParts = headerField.Show().Split(':');
string headerFieldShowName = headerFieldShowParts[0];
string headerFieldShowValue = headerFieldShowParts[1];
switch (headerFieldShowName)
{
case "Next header":
headerField.AssertValue((byte)header.NextHeader.Value);
break;
case "Length":
if (header.IsValid)
{
Assert.IsTrue(headerFieldShowValue.EndsWith(" (" + header.Length + " bytes)"));
}
break;
case "Router alert":
IpV6OptionRouterAlert routerAlert = (IpV6OptionRouterAlert)headerOptions.Options[optionsIndex++];
switch (headerFieldShowValue)
{
case " MLD (4 bytes)":
Assert.AreEqual(IpV6RouterAlertType.MulticastListenerDiscovery, routerAlert.RouterAlertType);
break;
case " RSVP (4 bytes)":
Assert.AreEqual(IpV6RouterAlertType.Rsvp, routerAlert.RouterAlertType);
break;
case " Unknown (4 bytes)":
MoreAssert.IsInRange((ushort)IpV6RouterAlertType.ActiveNetwork, (ushort)IpV6RouterAlertType.NextStepsInSignalingNatFirewallLayerProtocol, (ushort)routerAlert.RouterAlertType);
headerField.AssertValueInRange(0x05020002, 0x05020044);
break;
default:
throw new InvalidOperationException("Invalid ipv6 header route Router alert value " + headerFieldShowValue);
}
break;
case "Jumbo payload":
IpV6OptionJumboPayload jumboPayload = (IpV6OptionJumboPayload)headerOptions.Options[optionsIndex++];
Assert.AreEqual(" " + jumboPayload.JumboPayloadLength + " (6 bytes)", headerFieldShowValue);
break;
default:
throw new InvalidOperationException("Invalid ipv6 header unnamed field show name " + headerFieldShowName);
}
}
private static void TestTransmitQueueToLive(int numPacketsToSend, int packetSize, double secondsBetweenTimestamps, bool isSynced)
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
List <Packet> packetsToSend;
using (PacketSendBuffer queue = BuildQueue(out packetsToSend, numPacketsToSend, packetSize, SourceMac, DestinationMac, secondsBetweenTimestamps))
{
using (PacketCommunicator communicator = LivePacketDeviceTests.OpenLiveDevice())
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
communicator.Transmit(queue, isSynced);
DateTime lastTimestamp = DateTime.MinValue;
int numPacketsHandled = 0;
int numPacketsGot;
PacketCommunicatorReceiveResult result =
communicator.ReceiveSomePackets(out numPacketsGot, numPacketsToSend,
delegate(Packet packet)
{
Assert.AreEqual(packetsToSend[numPacketsHandled], packet);
if (numPacketsHandled > 0)
{
TimeSpan expectedDiff;
if (isSynced)
{
expectedDiff =
packetsToSend[numPacketsHandled].Timestamp -
packetsToSend[numPacketsHandled - 1].Timestamp;
}
else
{
expectedDiff = TimeSpan.Zero;
}
TimeSpan actualDiff = packet.Timestamp - lastTimestamp;
MoreAssert.IsInRange(
expectedDiff.Subtract(TimeSpan.FromSeconds(0.06)),
expectedDiff.Add(TimeSpan.FromSeconds(0.1)),
actualDiff, "actualDiff");
}
lastTimestamp = packet.Timestamp;
++numPacketsHandled;
});
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(numPacketsToSend, numPacketsGot, "numPacketsGot");
Assert.AreEqual(numPacketsToSend, numPacketsHandled, "numPacketsHandled");
}
}
}
private static void TestReceivePackets(int numPacketsToSend, int numPacketsToWait, int numPacketsToBreakLoop, double secondsToWait, int packetSize,
PacketCommunicatorReceiveResult expectedResult, int expectedNumPackets,
double expectedMinSeconds, double expectedMaxSeconds)
{
string testDescription = "NumPacketsToSend=" + numPacketsToSend + ". NumPacketsToWait=" + numPacketsToWait +
". NumPacketsToBreakLoop=" + numPacketsToBreakLoop + ". SecondsToWait=" +
secondsToWait + ". PacketSize=" + packetSize;
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
Packet sentPacket = _random.NextEthernetPacket(packetSize, SourceMac, DestinationMac);
PacketCommunicatorReceiveResult result = PacketCommunicatorReceiveResult.None;
for (int i = 0; i != numPacketsToSend; ++i)
{
communicator.SendPacket(sentPacket);
}
PacketHandler handler = new PacketHandler(sentPacket, communicator, numPacketsToBreakLoop);
Thread thread = new Thread(delegate()
{
if (numPacketsToBreakLoop == 0)
{
communicator.Break();
}
result = communicator.ReceivePackets(numPacketsToWait, handler.Handle);
});
DateTime startWaiting = DateTime.Now;
thread.Start();
if (!thread.Join(TimeSpan.FromSeconds(secondsToWait)))
{
thread.Abort();
}
DateTime finishedWaiting = DateTime.Now;
Assert.AreEqual(expectedResult, result, testDescription);
Assert.AreEqual(expectedNumPackets, handler.NumPacketsHandled);
MoreAssert.IsInRange(expectedMinSeconds, expectedMaxSeconds, (finishedWaiting - startWaiting).TotalSeconds);
}
}
public void SendAndReceievePacketTest()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPacketsToSend = 10;
using (PacketCommunicator communicator = OpenLiveDevice(100))
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
Packet packet;
DateTime startWaiting = DateTime.Now;
PacketCommunicatorReceiveResult result = communicator.ReceivePacket(out packet);
DateTime finishedWaiting = DateTime.Now;
Assert.AreEqual(PacketCommunicatorReceiveResult.Timeout, result);
Assert.AreEqual <uint>(0, communicator.TotalStatistics.PacketsCaptured);
MoreAssert.IsInRange(TimeSpan.FromSeconds(0.99), TimeSpan.FromSeconds(1.075), finishedWaiting - startWaiting);
Packet sentPacket = _random.NextEthernetPacket(200, 300, SourceMac, DestinationMac);
DateTime startSendingTime = DateTime.Now;
for (int i = 0; i != NumPacketsToSend; ++i)
{
communicator.SendPacket(sentPacket);
}
DateTime endSendingTime = DateTime.Now;
for (int i = 0; i != NumPacketsToSend; ++i)
{
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(100, packet.Length);
Assert.AreEqual <uint>(200, packet.OriginalLength);
MoreAssert.IsInRange(startSendingTime - TimeSpan.FromSeconds(1), endSendingTime + TimeSpan.FromSeconds(30), packet.Timestamp);
}
Assert.AreEqual <uint>(NumPacketsToSend, communicator.TotalStatistics.PacketsCaptured);
}
}
private static void TestReceiveSomePackets(int numPacketsToSend, int numPacketsToGet, int numPacketsToBreakLoop, int packetSize, bool nonBlocking,
PacketCommunicatorReceiveResult expectedResult, int expectedNumPackets, double expectedMinSeconds, double expectedMaxSeconds)
{
string testDescription = "NumPacketsToSend=" + numPacketsToSend + ". NumPacketsToGet=" + numPacketsToGet +
". NumPacketsToBreakLoop=" + numPacketsToBreakLoop + ". PacketSize=" + packetSize +
". NonBlocking=" + nonBlocking;
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
Packet packetToSend = _random.NextEthernetPacket(packetSize, SourceMac, DestinationMac);
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.NonBlocking = nonBlocking;
Assert.AreEqual(nonBlocking, communicator.NonBlocking);
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
int numPacketsGot;
for (int i = 0; i != numPacketsToSend; ++i)
{
communicator.SendPacket(packetToSend);
}
if (numPacketsToBreakLoop == 0)
{
communicator.Break();
}
PacketHandler handler = new PacketHandler(packetToSend, communicator, numPacketsToBreakLoop);
DateTime startWaiting = DateTime.Now;
PacketCommunicatorReceiveResult result = communicator.ReceiveSomePackets(out numPacketsGot, numPacketsToGet,
handler.Handle);
DateTime finishedWaiting = DateTime.Now;
Assert.AreEqual(expectedResult, result);
Assert.AreEqual(expectedNumPackets, numPacketsGot, "NumPacketsGot. Test: " + testDescription);
Assert.AreEqual(expectedNumPackets, handler.NumPacketsHandled, "NumPacketsHandled. Test: " + testDescription);
MoreAssert.IsInRange(expectedMinSeconds, expectedMaxSeconds, (finishedWaiting - startWaiting).TotalSeconds, testDescription);
}
}
public void ReceiveStatisticsTest()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPacketsToSend = 100;
const int PacketSize = 100;
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.Mode = PacketCommunicatorMode.Statistics;
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
Packet sentPacket = _random.NextEthernetPacket(PacketSize, SourceMac, DestinationMac);
PacketSampleStatistics statistics;
PacketCommunicatorReceiveResult result = communicator.ReceiveStatistics(out statistics);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
MoreAssert.IsInRange(DateTime.Now.AddSeconds(-1), DateTime.Now.AddSeconds(1), statistics.Timestamp);
Assert.AreEqual <ulong>(0, statistics.AcceptedPackets);
Assert.AreEqual <ulong>(0, statistics.AcceptedBytes);
for (int i = 0; i != NumPacketsToSend; ++i)
{
communicator.SendPacket(sentPacket);
}
result = communicator.ReceiveStatistics(out statistics);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
MoreAssert.IsInRange(DateTime.Now.AddSeconds(-1), DateTime.Now.AddSeconds(1), statistics.Timestamp);
Assert.AreEqual <ulong>(NumPacketsToSend, statistics.AcceptedPackets, "AcceptedPackets");
// Todo check byte statistics. See http://www.winpcap.org/pipermail/winpcap-users/2015-February/004931.html
// Assert.AreEqual<long>((sentPacket.Length * NumPacketsToSend), statistics.AcceptedBytes,
// "AcceptedBytes. Diff Per Packet: " +
// (statistics.AcceptedBytes - sentPacket.Length * NumPacketsToSend) /
// ((double)NumPacketsToSend));
}
}
public void RandomGreTest()
{
EthernetLayer ethernetLayer = new EthernetLayer
{
Source = new MacAddress("00:01:02:03:04:05"),
Destination = new MacAddress("A0:A1:A2:A3:A4:A5")
};
int seed = new Random().Next();
Console.WriteLine("Seed: " + seed);
Random random = new Random(seed);
for (int i = 0; i != 200; ++i)
{
IpV4Layer ipV4Layer = random.NextIpV4Layer(null);
ipV4Layer.HeaderChecksum = null;
Layer ipLayer = random.NextBool() ? (Layer)ipV4Layer : random.NextIpV6Layer(IpV4Protocol.Gre, false);
GreLayer greLayer = random.NextGreLayer();
PayloadLayer payloadLayer = random.NextPayloadLayer(random.Next(100));
PacketBuilder packetBuilder = new PacketBuilder(ethernetLayer, ipLayer, greLayer, payloadLayer);
Packet packet = packetBuilder.Build(DateTime.Now);
if (greLayer.Checksum == null &&
!new[] { EthernetType.IpV4, EthernetType.IpV6, EthernetType.Arp, EthernetType.VLanTaggedFrame }.Contains(packet.Ethernet.Ip.Gre.ProtocolType))
{
Assert.IsTrue(packet.IsValid, "IsValid, ProtocolType=" + packet.Ethernet.Ip.Gre.ProtocolType);
}
// Ethernet
ethernetLayer.EtherType = ipLayer == ipV4Layer ? EthernetType.IpV4 : EthernetType.IpV6;
Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer(), "Ethernet Layer");
ethernetLayer.EtherType = EthernetType.None;
// IP.
if (ipLayer == ipV4Layer)
{
// IPv4.
ipV4Layer.Protocol = IpV4Protocol.Gre;
ipV4Layer.HeaderChecksum = ((IpV4Layer)packet.Ethernet.Ip.ExtractLayer()).HeaderChecksum;
Assert.AreEqual(ipV4Layer, packet.Ethernet.Ip.ExtractLayer());
ipV4Layer.HeaderChecksum = null;
Assert.AreEqual(ipV4Layer.Length, packet.Ethernet.IpV4.HeaderLength);
Assert.IsTrue(packet.Ethernet.IpV4.IsHeaderChecksumCorrect);
Assert.AreEqual(ipV4Layer.Length + greLayer.Length + payloadLayer.Length,
packet.Ethernet.Ip.TotalLength);
Assert.AreEqual(IpV4Datagram.DefaultVersion, packet.Ethernet.Ip.Version);
}
else
{
// IPv6.
Assert.AreEqual(ipLayer, packet.Ethernet.Ip.ExtractLayer());
}
// GRE
GreDatagram actualGre = packet.Ethernet.Ip.Gre;
GreLayer actualGreLayer = (GreLayer)actualGre.ExtractLayer();
if (greLayer.ChecksumPresent && greLayer.Checksum == null)
{
Assert.IsTrue(actualGre.IsChecksumCorrect);
greLayer.Checksum = actualGre.Checksum;
}
Assert.AreEqual(greLayer, actualGreLayer, "Layer");
if (actualGreLayer.Key != null)
{
actualGreLayer.SetKey(actualGreLayer.KeyPayloadLength.Value, actualGreLayer.KeyCallId.Value);
}
else
{
Assert.IsNull(actualGreLayer.KeyPayloadLength);
Assert.IsNull(actualGreLayer.KeyCallId);
}
Assert.AreEqual(greLayer, actualGreLayer, "Layer");
if (actualGre.KeyPresent)
{
Assert.AreEqual(greLayer.KeyPayloadLength, actualGre.KeyPayloadLength, "KeyPayloadLength");
Assert.AreEqual(greLayer.KeyCallId, actualGre.KeyCallId, "KeyCallId");
}
Assert.AreNotEqual(random.NextGreLayer(), actualGreLayer, "Not Layer");
Assert.AreEqual(greLayer.Length, actualGre.HeaderLength);
Assert.IsTrue(actualGre.KeyPresent ^ (greLayer.Key == null));
MoreAssert.IsSmaller(8, actualGre.RecursionControl);
MoreAssert.IsSmaller(32, actualGre.FutureUseBits);
Assert.IsTrue(actualGre.RoutingPresent ^ (greLayer.Routing == null && greLayer.RoutingOffset == null));
Assert.IsTrue(actualGre.SequenceNumberPresent ^ (greLayer.SequenceNumber == null));
Assert.IsTrue(!actualGre.StrictSourceRoute || actualGre.RoutingPresent);
if (actualGre.RoutingPresent)
{
Assert.IsNotNull(actualGre.ActiveSourceRouteEntryIndex);
if (actualGre.ActiveSourceRouteEntryIndex < actualGre.Routing.Count)
{
Assert.IsNotNull(actualGre.ActiveSourceRouteEntry);
}
foreach (GreSourceRouteEntry entry in actualGre.Routing)
{
Assert.AreNotEqual(entry, 2);
Assert.AreEqual(entry.GetHashCode(), entry.GetHashCode());
switch (entry.AddressFamily)
{
case GreSourceRouteEntryAddressFamily.AsSourceRoute:
GreSourceRouteEntryAs asEntry = (GreSourceRouteEntryAs)entry;
MoreAssert.IsInRange(0, asEntry.AsNumbers.Count, asEntry.NextAsNumberIndex);
if (asEntry.NextAsNumberIndex != asEntry.AsNumbers.Count)
{
Assert.AreEqual(asEntry.AsNumbers[asEntry.NextAsNumberIndex], asEntry.NextAsNumber);
}
break;
case GreSourceRouteEntryAddressFamily.IpSourceRoute:
GreSourceRouteEntryIp ipEntry = (GreSourceRouteEntryIp)entry;
MoreAssert.IsInRange(0, ipEntry.Addresses.Count, ipEntry.NextAddressIndex);
if (ipEntry.NextAddressIndex != ipEntry.Addresses.Count)
{
Assert.AreEqual(ipEntry.Addresses[ipEntry.NextAddressIndex], ipEntry.NextAddress);
}
break;
default:
GreSourceRouteEntryUnknown unknownEntry = (GreSourceRouteEntryUnknown)entry;
MoreAssert.IsInRange(0, unknownEntry.Data.Length, unknownEntry.PayloadOffset);
break;
}
}
}
else
{
Assert.IsNull(actualGre.ActiveSourceRouteEntry);
}
Assert.IsNotNull(actualGre.Payload);
switch (actualGre.ProtocolType)
{
case EthernetType.IpV4:
Assert.IsNotNull(actualGre.IpV4);
break;
case EthernetType.Arp:
Assert.IsNotNull(actualGre.Arp);
break;
}
}
}
protected override bool CompareField(XElement field, Datagram datagram)
{
GreDatagram greDatagram = (GreDatagram)datagram;
switch (field.Name())
{
case "gre.flags_and_version":
XElement[] innerFields = field.Fields().ToArray();
MoreAssert.IsInRange(8, 9, innerFields.Length);
int currentInnerFieldIndex = 0;
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.ChecksumPresent);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.RoutingPresent);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.KeyPresent);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.SequenceNumberPresent);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.StrictSourceRoute);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.RecursionControl);
if (innerFields.Length == 9)
{
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.AcknowledgmentSequenceNumberPresent);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(greDatagram.FutureUseBits);
}
else
{
byte futureUseBitsValue = (byte)((greDatagram.AcknowledgmentSequenceNumberPresent.ToInt() << 4) | greDatagram.FutureUseBits);
innerFields[currentInnerFieldIndex++].AssertShowDecimal(futureUseBitsValue);
}
innerFields[currentInnerFieldIndex].AssertShowDecimal((byte)greDatagram.Version);
break;
case "data.len":
field.AssertShowDecimal(
greDatagram.Payload.Length + (greDatagram.AcknowledgmentSequenceNumberPresent &&
(greDatagram.Version != GreVersion.EnhancedGre || !greDatagram.SequenceNumberPresent)
? 4
: 0), "GRE data.len");
field.AssertNoFields();
break;
case "gre.checksum":
field.AssertShowHex(greDatagram.Checksum);
field.AssertNoFields();
break;
case "gre.key.payload_length":
field.AssertShowDecimal(greDatagram.KeyPayloadLength);
field.AssertNoFields();
break;
case "gre.key.call_id":
field.AssertShowDecimal(greDatagram.KeyCallId);
field.AssertNoFields();
break;
case "gre.ack_number":
field.AssertShowDecimal(greDatagram.AcknowledgmentSequenceNumber);
field.AssertNoFields();
break;
case "gre.sequence_number":
field.AssertShowDecimal(greDatagram.SequenceNumber);
field.AssertNoFields();
break;
case "gre.offset":
field.AssertShowDecimal(greDatagram.RoutingOffset);
field.AssertNoFields();
break;
case "gre.routing":
field.AssertShow("");
field.AssertNoFields();
break;
case "gre.routing.address_family":
if (_routingEntryIndex == greDatagram.Routing.Count)
field.AssertShowDecimal(0);
else
field.AssertShowDecimal((ushort)greDatagram.Routing[_routingEntryIndex].AddressFamily);
field.AssertNoFields();
break;
case "gre.routing.sre_offset":
if (_routingEntryIndex == greDatagram.Routing.Count)
field.AssertShowDecimal(0);
else
field.AssertShowDecimal(greDatagram.Routing[_routingEntryIndex].PayloadOffset);
field.AssertNoFields();
break;
case "gre.routing.src_length":
if (_routingEntryIndex == greDatagram.Routing.Count)
field.AssertShowDecimal(0);
else
field.AssertShowDecimal(greDatagram.Routing[_routingEntryIndex].PayloadLength);
field.AssertNoFields();
break;
case "gre.routing.information":
if (_routingEntryIndex != greDatagram.Routing.Count)
{
switch (greDatagram.Routing[_routingEntryIndex].AddressFamily)
{
case GreSourceRouteEntryAddressFamily.IpSourceRoute:
field.AssertValue(((GreSourceRouteEntryIp)greDatagram.Routing[_routingEntryIndex]).Addresses);
break;
case GreSourceRouteEntryAddressFamily.AsSourceRoute:
field.AssertValue(((GreSourceRouteEntryAs)greDatagram.Routing[_routingEntryIndex]).AsNumbers);
break;
default:
field.AssertValue(((GreSourceRouteEntryUnknown)greDatagram.Routing[_routingEntryIndex]).Data);
break;
}
++_routingEntryIndex;
}
field.AssertNoFields();
break;
case "gre.proto":
field.AssertShowHex((ushort)greDatagram.ProtocolType);
field.AssertNoFields();
break;
case "gre.key":
field.AssertShowHex(greDatagram.Key);
field.AssertNoFields();
break;
case "data":
case "data.data":
field.AssertDataField(greDatagram.Payload);
break;
default:
Assert.Fail("Invalid field name: " + field.Name());
break;
}
return true;
}
public static void AssertValueInRange(this XElement element, string expectedMinimumValue, string expectedMaximumValue)
{
MoreAssert.IsInRange(expectedMinimumValue, expectedMaximumValue, element.Value());
}