Commit e0362594 authored by Brickner_cp's avatar Brickner_cp

Refactor ComparePacketsToWiresharkTest.

parent 4c1b2b1e
......@@ -75,6 +75,17 @@
<Compile Include="MarshalingServicesTests.cs" />
<Compile Include="MoreIpV4Option.cs" />
<Compile Include="MoreTcpOption.cs" />
<Compile Include="WiresharkDatagramComparer.cs" />
<Compile Include="WiresharkDatagramComparerArp.cs" />
<Compile Include="WiresharkDatagramComparerEthernet.cs" />
<Compile Include="WiresharkDatagramComparerGre.cs" />
<Compile Include="WiresharkDatagramComparerHttp.cs" />
<Compile Include="WiresharkDatagramComparerIcmp.cs" />
<Compile Include="WiresharkDatagramComparerIgmp.cs" />
<Compile Include="WiresharkDatagramComparerIpV4.cs" />
<Compile Include="WiresharkDatagramComparerSimple.cs" />
<Compile Include="WiresharkDatagramComparerTcp.cs" />
<Compile Include="WiresharkDatagramComparerUdp.cs" />
<Compile Include="WiresharkStringExtensions.cs" />
<Compile Include="XElementExtensions.cs" />
<Compile Include="PacketDumpFileTests.cs" />
......
using System.Reflection;
using System.Xml.Linq;
using PcapDotNet.Base;
using PcapDotNet.Packets;
namespace PcapDotNet.Core.Test
{
internal abstract class WiresharkDatagramComparer
{
public Datagram Compare(XElement layer, object datagramParent)
{
PropertyInfo property = datagramParent.GetType().GetProperty(PropertyName);
if (property == null)
return null;
Datagram datagram = (Datagram)property.GetValue(datagramParent);
if (!Ignore(datagram))
CompareDatagram(layer, datagramParent as Datagram, datagram);
return datagram;
}
protected abstract string PropertyName { get; }
protected abstract bool CompareField(XElement field, Datagram parentDatagram, Datagram datagram);
protected virtual bool Ignore(Datagram datagram)
{
return false;
}
protected void CompareDatagram(XElement layer, Datagram parentDatagram, Datagram datagram)
{
foreach (var field in layer.Fields())
{
if (!CompareField(field, parentDatagram, datagram))
break;
}
WiresharkCompareTests.CompareProtocols(datagram, layer);
}
public static WiresharkDatagramComparer GetComparer(string name)
{
switch (name)
{
case "eth":
return new WiresharkDatagramComparerEthernet();
case "arp":
return new WiresharkDatagramComparerArp();
case "ip":
return new WiresharkDatagramComparerIpV4();
case "igmp":
return new WiresharkDatagramComparerIgmp();
case "icmp":
return new WiresharkDatagramComparerIcmp();
case "gre":
return new WiresharkDatagramComparerGre();
case "udp":
return new WiresharkDatagramComparerUdp();
case "tcp":
return new WiresharkDatagramComparerTcp();
case "http":
return new WiresharkDatagramComparerHttp();
default:
return null;
}
}
}
}
\ No newline at end of file
using System;
using System.Xml.Linq;
using PcapDotNet.Packets;
using PcapDotNet.Packets.Arp;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerArp : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "Arp"; }
}
protected override bool CompareField(XElement field, Datagram datagram)
{
ArpDatagram arpDatagram = (ArpDatagram)datagram;
switch (field.Name())
{
case "arp.hw.type":
field.AssertShowHex((ushort)arpDatagram.HardwareType);
break;
case "arp.proto.type":
field.AssertShowHex((ushort)arpDatagram.ProtocolType);
break;
case "arp.hw.size":
field.AssertShowDecimal(arpDatagram.HardwareLength);
break;
case "arp.proto.size":
field.AssertShowDecimal(arpDatagram.ProtocolLength);
break;
case "arp.opcode":
field.AssertShowHex((ushort)arpDatagram.Operation);
break;
case "arp.src.hw":
case "arp.src.hw_mac":
field.AssertShow(arpDatagram.SenderHardwareAddress);
break;
case "arp.src.proto":
field.AssertShow(arpDatagram.SenderProtocolAddress);
break;
case "arp.src.proto_ipv4":
field.AssertShow(arpDatagram.SenderProtocolIpV4Address.ToString());
break;
case "arp.dst.hw":
case "arp.dst.hw_mac":
field.AssertShow(arpDatagram.TargetHardwareAddress);
break;
case "arp.dst.proto":
field.AssertShow(arpDatagram.TargetProtocolAddress);
break;
case "arp.dst.proto_ipv4":
field.AssertShow(arpDatagram.TargetProtocolIpV4Address.ToString());
break;
case "arp.isgratuitous":
break;
default:
throw new InvalidOperationException("Invalid arp field " + field.Name());
}
return true;
}
}
}
\ No newline at end of file
using System;
using System.Xml.Linq;
using PcapDotNet.Packets;
using PcapDotNet.Packets.Ethernet;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerEthernet : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "Ethernet"; }
}
protected override bool CompareField(XElement field, Datagram datagram)
{
EthernetDatagram ethernetDatagram = (EthernetDatagram)datagram;
switch (field.Name())
{
case "eth.dst":
CompareEthernetAddress(field, ethernetDatagram.Destination);
break;
case "eth.src":
CompareEthernetAddress(field, ethernetDatagram.Source);
break;
case "eth.type":
field.AssertShowHex((ushort)ethernetDatagram.EtherType);
break;
case "eth.trailer":
if (ethernetDatagram.Trailer != null)
field.AssertValue(ethernetDatagram.Trailer);
break;
case "":
if (ethernetDatagram.Trailer != null)
field.AssertValue(ethernetDatagram.FrameCheckSequence);
break;
default:
throw new InvalidOperationException("Invalid etherent field " + field.Name());
}
return true;
}
private static void CompareEthernetAddress(XElement element, MacAddress address)
{
foreach (var field in element.Fields())
{
switch (field.Name())
{
case "eth.addr":
field.AssertShow(address.ToString().ToLower());
break;
case "eth.ig":
case "eth.lg":
break;
default:
throw new InvalidOperationException("Invalid ethernet address field " + field.Name());
}
}
}
}
}
\ No newline at end of file
using System;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PcapDotNet.Base;
using PcapDotNet.Packets;
using PcapDotNet.Packets.Http;
using PcapDotNet.Packets.TestUtils;
using PcapDotNet.TestUtils;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerHttp : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "Http"; }
}
protected override bool Ignore(Datagram datagram)
{
HttpDatagram httpDatagram = (HttpDatagram)datagram;
return (httpDatagram.Header != null && httpDatagram.Header.ContentLength != null && httpDatagram.Header.TransferEncoding != null);
}
protected override bool CompareField(XElement field, Datagram datagram)
{
HttpDatagram httpDatagram = (HttpDatagram)datagram;
if (field.Name() == "data" || field.Name() == "data.data")
{
if (field.Name() == "data")
field.AssertNoShow();
MoreAssert.AreSequenceEqual(httpDatagram.Take(_data.Length / 2), HexEncoding.Instance.GetBytes(_data.ToString()));
// string previousData = data.ToString();
// for (int i = 0; i != previousData.Length / 2; ++i)
// {
// byte value = Convert.ToByte(previousData.Substring(i * 2, 2), 16);
// Assert.AreEqual(httpDatagram[i], value);
// }
field.AssertValue(httpDatagram.Skip(_data.Length / 2));
return false;
}
string fieldShow = field.Show();
string httpFieldName;
switch (field.Name())
{
case "http.request":
field.AssertShowDecimal(httpDatagram.IsRequest);
break;
case "http.response":
field.AssertShowDecimal(httpDatagram.IsResponse);
break;
case "":
if (fieldShow == "HTTP chunked response")
{
throw new InvalidOperationException("HTTP chunked response");
}
_data.Append(field.Value());
if (fieldShow == @"\r\n")
break;
if (_isFirstEmptyName)
{
CompareHttpFirstLine(field, httpDatagram);
_isFirstEmptyName = false;
}
else if (fieldShow.StartsWith("Content-encoded entity body"))
{
break;
}
else
{
fieldShow = EncodingExtensions.Iso88591.GetString(HexEncoding.Instance.GetBytes(field.Value()));
fieldShow = fieldShow.Substring(0, fieldShow.Length - 2);
int colonIndex = fieldShow.IndexOf(':');
MoreAssert.IsBiggerOrEqual(0, colonIndex, "Can't find colon in field with empty name");
if (httpDatagram.Header == null)
{
Assert.IsTrue(httpDatagram.IsRequest);
Assert.IsNull(httpDatagram.Version);
break;
}
httpFieldName = fieldShow.Substring(0, colonIndex);
string fieldValue = fieldShow.Substring(colonIndex + 1).SkipWhile(c => c == ' ').TakeWhile(c => c != '\\').SequenceToString();
string expectedFieldValue = httpDatagram.Header[httpFieldName].ValueString;
Assert.IsTrue(expectedFieldValue.Contains(fieldValue),
string.Format("{0} <{1}> doesn't contain <{2}>", field.Name(), expectedFieldValue, fieldValue));
}
break;
case "data.len":
field.AssertShowDecimal(httpDatagram.Length - _data.Length / 2);
break;
case "http.host":
case "http.user_agent":
case "http.accept":
case "http.accept_language":
case "http.accept_encoding":
case "http.connection":
case "http.cookie":
case "http.cache_control":
case "http.content_encoding":
case "http.date":
case "http.referer":
case "http.last_modified":
case "http.server":
case "http.set_cookie":
case "http.location":
_data.Append(field.Value());
httpFieldName = field.Name().Substring(5).Replace('_', '-');
HttpField httpField = httpDatagram.Header[httpFieldName];
if (!field.Value().EndsWith("0d0a"))
Assert.IsNull(httpField);
else
{
string fieldValue = field.Show().Replace("\\\"", "\"");
string expectedFieldValue = httpField.ValueString;
Assert.IsTrue(expectedFieldValue.Contains(fieldValue),
string.Format("{0} <{1}> doesn't contain <{2}>", field.Name(), expectedFieldValue, fieldValue));
}
break;
case "http.content_length_header":
_data.Append(field.Value());
field.AssertShowDecimal(httpDatagram.Header.ContentLength.ContentLength.Value);
break;
case "http.content_type":
_data.Append(field.Value());
string[] mediaType = fieldShow.Split(new[] {';', ' ', '/'}, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(httpDatagram.Header.ContentType.MediaType, mediaType[0]);
Assert.AreEqual(httpDatagram.Header.ContentType.MediaSubtype, mediaType[1]);
int fieldShowParametersStart = fieldShow.IndexOf(';');
if (fieldShowParametersStart == -1)
Assert.IsFalse(httpDatagram.Header.ContentType.Parameters.Any());
else
Assert.AreEqual(
httpDatagram.Header.ContentType.Parameters.Select(pair => pair.Key + '=' + pair.Value.ToWiresharkLiteral()).SequenceToString(';'),
fieldShow.Substring(fieldShowParametersStart + 1));
break;
case "http.transfer_encoding":
_data.Append(field.Value());
Assert.AreEqual(fieldShow.ToWiresharkLowerLiteral(),
httpDatagram.Header.TransferEncoding.TransferCodings.SequenceToString(',').ToWiresharkLiteral());
break;
default:
throw new InvalidOperationException("Invalid HTTP field " + field.Name());
}
return true;
}
private static void CompareHttpFirstLine(XElement httpFirstLineElement, HttpDatagram httpDatagram)
{
foreach (var field in httpFirstLineElement.Fields())
{
switch (field.Name())
{
case "http.request.method":
Assert.IsTrue(httpDatagram.IsRequest, field.Name() + " IsRequest");
field.AssertShow(((HttpRequestDatagram)httpDatagram).Method.Method);
break;
case "http.request.uri":
Assert.IsTrue(httpDatagram.IsRequest, field.Name() + " IsRequest");
field.AssertShow(((HttpRequestDatagram)httpDatagram).Uri.ToWiresharkLiteral());
break;
case "http.request.version":
if (httpDatagram.Version == null)
field.AssertShow(string.Empty);
else
field.AssertShow(httpDatagram.Version.ToString());
break;
case "http.response.code":
Assert.IsTrue(httpDatagram.IsResponse, field.Name() + " IsResponse");
field.AssertShowDecimal(((HttpResponseDatagram)httpDatagram).StatusCode.Value);
break;
default:
throw new InvalidOperationException("Invalid HTTP first line field " + field.Name());
}
}
}
readonly StringBuilder _data = new StringBuilder();
bool _isFirstEmptyName = true;
}
}
\ No newline at end of file
using System;
using System.Text;
using System.Xml.Linq;
using PcapDotNet.Packets;
using PcapDotNet.Packets.Icmp;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerIcmp : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "Icmp"; }
}
protected override bool CompareField(XElement field, Datagram datagram)
{
IcmpDatagram icmpDatagram = (IcmpDatagram)datagram;
switch (field.Name())
{
case "icmp.type":
field.AssertShowDecimal((byte)icmpDatagram.MessageType);
break;
case "icmp.code":
field.AssertShowDecimal(icmpDatagram.Code);
break;
case "icmp.checksum_bad":
field.AssertShowDecimal(!icmpDatagram.IsChecksumCorrect);
break;
case "icmp.checksum":
field.AssertShowHex(icmpDatagram.Checksum);
break;
case "data":
var casted1 = icmpDatagram as IcmpIpV4HeaderPlus64BitsPayloadDatagram;
if (casted1 != null)
field.AssertValue(casted1.IpV4.Payload);
else
field.AssertValue(icmpDatagram.Payload);
break;
case "data.data":
var casted2 = icmpDatagram as IcmpIpV4HeaderPlus64BitsPayloadDatagram;
if (casted2 != null)
field.AssertShow(casted2.IpV4.Payload);
else
field.AssertShow(icmpDatagram.Payload);
break;
case "data.len":
var casted3 = icmpDatagram as IcmpIpV4HeaderPlus64BitsPayloadDatagram;
if (casted3 != null)
field.AssertShowDecimal(casted3.IpV4.Payload.Length);
else
field.AssertShowDecimal(icmpDatagram.Payload.Length);
break;
case "":
switch (icmpDatagram.MessageType)
{
case IcmpMessageType.ParameterProblem:
if (field.Show() != "Unknown session type")
field.AssertShow("Pointer: " + ((IcmpParameterProblemDatagram)icmpDatagram).Pointer);
break;
case IcmpMessageType.RouterAdvertisement:
IcmpRouterAdvertisementDatagram routerAdvertisementDatagram = (IcmpRouterAdvertisementDatagram)icmpDatagram;
string fieldName = field.Show().Split(':')[0];
switch (fieldName)
{
case "Number of addresses":
field.AssertShow(fieldName + ": " + routerAdvertisementDatagram.NumberOfAddresses);
break;
case "Address entry size":
field.AssertShow(fieldName + ": " + routerAdvertisementDatagram.AddressEntrySize);
break;
case "Lifetime":
TimeSpan actualLifetime = routerAdvertisementDatagram.Lifetime;
StringBuilder actualLifetimeString = new StringBuilder(fieldName + ": ");
if (actualLifetime.Hours != 0)
{
actualLifetimeString.Append(actualLifetime.Hours + " hour");
if (actualLifetime.Hours != 1)
actualLifetimeString.Append('s');
}
if (actualLifetime.Minutes != 0)
{
if (actualLifetime.Hours != 0)
actualLifetimeString.Append(", ");
actualLifetimeString.Append(actualLifetime.Minutes + " minute");
if (actualLifetime.Minutes != 1)
actualLifetimeString.Append('s');
}
if (actualLifetime.Seconds != 0)
{
if (actualLifetime.Hours != 0 || actualLifetime.Minutes != 0)
actualLifetimeString.Append(", ");
actualLifetimeString.Append(actualLifetime.Seconds + " second");
if (actualLifetime.Seconds != 1)
actualLifetimeString.Append('s');
}
break;
case "Router address":
field.AssertShow(fieldName + ": " + routerAdvertisementDatagram.Entries[_routerIndex].RouterAddress);
break;
case "Preference level":
field.AssertShow(fieldName + ": " + routerAdvertisementDatagram.Entries[_routerIndex++].RouterAddressPreference);
break;
default:
throw new InvalidOperationException("Invalid icmp " + icmpDatagram.MessageType + " field " + fieldName);
}
break;
}
break;
case "icmp.ident":
field.AssertShowHex(((IcmpIdentifiedDatagram)icmpDatagram).Identifier);
break;
case "icmp.seq":
field.AssertShowDecimal(((IcmpIdentifiedDatagram)icmpDatagram).SequenceNumber);
break;
case "icmp.seq_le":
byte[] sequenceNumberBuffer = new byte[sizeof(ushort)];
sequenceNumberBuffer.Write(0, ((IcmpIdentifiedDatagram)icmpDatagram).SequenceNumber, Endianity.Big);
ushort lowerEndianSequenceNumber = sequenceNumberBuffer.ReadUShort(0, Endianity.Small);
field.AssertShowDecimal(lowerEndianSequenceNumber);
break;
case "icmp.redir_gw":
field.AssertShow(((IcmpRedirectDatagram)icmpDatagram).GatewayInternetAddress.ToString());
break;
case "icmp.mtu":
field.AssertShowDecimal(((IcmpDestinationUnreachableDatagram)icmpDatagram).NextHopMaximumTransmissionUnit);
break;
default:
if (!field.Name().StartsWith("lt2p.") &&
!field.Name().StartsWith("pweth."))
throw new InvalidOperationException("Invalid icmp field " + field.Name());
break;
}
return true;
}
private int _routerIndex;
}
}
\ No newline at end of file
using System;
using System.Linq;
using System.Xml.Linq;
using PcapDotNet.Base;
using PcapDotNet.Packets;
using PcapDotNet.Packets.Igmp;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerIgmp : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "Igmp"; }
}
protected override bool CompareField(XElement field, Datagram datagram)
{
IgmpDatagram igmpDatagram = (IgmpDatagram)datagram;
switch (field.Name())
{
case "igmp.version":
if (field.Show() == "0")
return false; // TODO: support IGMP version 0.
field.AssertShowDecimal(igmpDatagram.Version);
break;
case "igmp.type":
field.AssertShowHex((byte)igmpDatagram.MessageType);
break;
case "igmp.checksum":
field.AssertShowHex(igmpDatagram.Checksum);
break;
case "igmp.maddr":
field.AssertShow(igmpDatagram.GroupAddress.ToString());
break;
case "igmp.max_resp":
field.AssertShowDecimal((int)((igmpDatagram.MaxResponseTime.TotalSeconds + 0.05) * 10));
break;
case "igmp.checksum_bad":
field.AssertShowDecimal(!igmpDatagram.IsChecksumCorrect);
break;
case "igmp.num_grp_recs":
field.AssertShowDecimal(igmpDatagram.NumberOfGroupRecords);
break;
case "":
switch (igmpDatagram.MessageType)
{
case IgmpMessageType.MembershipReportVersion3:
CompareIgmpGroupRecord(field, igmpDatagram.GroupRecords[_groupRecordIndex++]);
break;
case IgmpMessageType.MembershipQuery:
CompareDatagram(field, null, igmpDatagram);
break;
default:
if (typeof(IgmpMessageType).GetEnumValues<IgmpMessageType>().Contains(igmpDatagram.MessageType))
throw new InvalidOperationException("Invalid message type " + igmpDatagram.MessageType);
field.AssertValue(igmpDatagram.Skip(1));
// field.AssertShow(igmpDatagram.Skip(1));
break;
}
break;
case "igmp.s":
field.AssertShowDecimal(igmpDatagram.IsSuppressRouterSideProcessing);
break;
case "igmp.qrv":
field.AssertShowDecimal(igmpDatagram.QueryRobustnessVariable);
break;
case "igmp.qqic":
field.AssertShowDecimal(igmpDatagram.QueryIntervalCode);
break;
case "igmp.num_src":
field.AssertShowDecimal(igmpDatagram.NumberOfSources);
break;
case "igmp.saddr":
field.AssertShow(igmpDatagram.SourceAddresses[_sourceAddressIndex++].ToString());
break;
case "igmp.identifier":
// todo support IGMP version 0 and IGMP identifier.
break;
case "igmp.mtrace.max_hops":
// todo support IGMP traceroute http://www.ietf.org/proceedings/48/I-D/idmr-traceroute-ipm-07.txt.
break;
default:
throw new InvalidOperationException("Invalid igmp field " + field.Name());
}
return true;
}
private static void CompareIgmpGroupRecord(XElement groupRecord, IgmpGroupRecordDatagram groupRecordDatagram)
{
int sourceAddressIndex = 0;
foreach (var field in groupRecord.Fields())
{
switch (field.Name())
{
case "igmp.record_type":
field.AssertShowDecimal((byte)groupRecordDatagram.RecordType);
break;
case "igmp.aux_data_len":
field.AssertShowDecimal(groupRecordDatagram.AuxiliaryDataLength / 4);
break;
case "igmp.num_src":
field.AssertShowDecimal(groupRecordDatagram.NumberOfSources);
break;
case "igmp.maddr":
field.AssertShow(groupRecordDatagram.MulticastAddress.ToString());
break;
case "igmp.saddr":
field.AssertShow(groupRecordDatagram.SourceAddresses[sourceAddressIndex++].ToString());
break;
case "igmp.aux_data":
field.AssertShow(groupRecordDatagram.AuxiliaryData);
break;
default:
throw new InvalidOperationException("Invalid igmp group record field " + field.Name());
}
}
}
private int _groupRecordIndex;
private int _sourceAddressIndex;
}
}
\ No newline at end of file
using System;
using System.Linq;
using System.Xml.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PcapDotNet.Packets;
using PcapDotNet.Packets.IpV4;
using PcapDotNet.TestUtils;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerIpV4 : WiresharkDatagramComparerSimple
{
protected override string PropertyName
{
get { return "IpV4"; }
}
protected override bool CompareField(XElement field, Datagram datagram)
{
IpV4Datagram ipV4Datagram = (IpV4Datagram)datagram;
switch (field.Name())
{
case "ip.version":
field.AssertShowDecimal(ipV4Datagram.Version);
break;
case "ip.hdr_len":
field.AssertShowDecimal(ipV4Datagram.HeaderLength);
break;
case "ip.dsfield":
field.AssertShowDecimal((int)ipV4Datagram.TypeOfService);
break;
case "ip.len":
field.AssertShowDecimal(ipV4Datagram.TotalLength);
break;
case "ip.id":
field.AssertShowHex(ipV4Datagram.Identification);
break;
case "ip.flags":
field.AssertShowHex((byte)((ushort)ipV4Datagram.Fragmentation.Options >> 13));
break;
case "ip.frag_offset":
field.AssertShowDecimal(ipV4Datagram.Fragmentation.Offset);
break;
case "ip.ttl":
field.AssertShowDecimal(ipV4Datagram.Ttl);
break;
case "ip.proto":
field.AssertShowDecimal((byte)ipV4Datagram.Protocol);
break;
case "ip.checksum":
field.AssertShowHex(ipV4Datagram.HeaderChecksum);
foreach (var checksumField in field.Fields())
{
switch (checksumField.Name())
{
case "ip.checksum_good":
checksumField.AssertShowDecimal(ipV4Datagram.IsHeaderChecksumCorrect);
break;
case "ip.checksum_bad":
if (ipV4Datagram.Length < IpV4Datagram.HeaderMinimumLength ||
ipV4Datagram.Length < ipV4Datagram.HeaderLength)
break;
checksumField.AssertShowDecimal(!ipV4Datagram.IsHeaderChecksumCorrect);
break;
}
}
break;
case "ip.src":
case "ip.src_host":
field.AssertShow(ipV4Datagram.Source.ToString());
break;
case "ip.dst":
case "ip.dst_host":
field.AssertShow(ipV4Datagram.Destination.ToString());
break;
case "ip.addr":
case "ip.host":
Assert.IsTrue(field.Show() == ipV4Datagram.Source.ToString() ||
field.Show() == ipV4Datagram.Destination.ToString());
break;
case "":
CompareIpV4Options(field, ipV4Datagram.Options);
break;
default:
throw new InvalidOperationException("Invalid ip field " + field.Name());
}
return true;
}
private static void CompareIpV4Options(XElement element, IpV4Options options)
{
int currentOptionIndex = 0;
foreach (var field in element.Fields())
{
if (currentOptionIndex >= options.Count)
{
Assert.IsFalse(options.IsValid);
Assert.IsTrue(field.Show() == "Commercial IP security option" ||
field.Show() == "Loose source route (length byte past end of options)" ||
field.Show() == "Time stamp:" ||
field.Show().StartsWith("Unknown") ||
field.Show().StartsWith("Security") ||
field.Show().StartsWith("Router Alert (with option length = ") ||
field.Show().StartsWith("Stream identifier (with option length = ") ||
field.Show().Contains("with too") ||
field.Show().Contains(" bytes says option goes past end of options") ||
field.Show().Contains("(length byte past end of options)") ||
XElementExtensions.Show(field.Fields().First()).StartsWith("Pointer: ") && XElementExtensions.Show(field.Fields().First()).EndsWith(" (points to middle of address)") ||
field.Fields().Where(value => value.Show() == "(suboption would go past end of option)").Count() != 0, field.Show());
break;
}
IpV4Option option = options[currentOptionIndex++];
if (option.OptionType == IpV4OptionType.BasicSecurity ||
option.OptionType == IpV4OptionType.TraceRoute)
{
Assert.IsTrue(field.Show().StartsWith(option.GetWiresharkString()));
continue; // Wireshark doesn't support
}
field.AssertShow(option.GetWiresharkString());
if ((option is IpV4OptionUnknown))
continue;
var optionShows = from f in field.Fields() select f.Show();
MoreAssert.AreSequenceEqual(optionShows, option.GetWiresharkSubfieldStrings());
}
}
}
}
\ No newline at end of file
using System.Xml.Linq;
using PcapDotNet.Packets;
namespace PcapDotNet.Core.Test
{
internal abstract class WiresharkDatagramComparerSimple : WiresharkDatagramComparer
{
protected override sealed bool CompareField(XElement field, Datagram parentDatagram, Datagram datagram)
{
return CompareField(field, datagram);
}
protected abstract bool CompareField(XElement field, Datagram parentDatagram);
}
}
\ No newline at end of file
using System;
using System.Xml.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PcapDotNet.Packets;
using PcapDotNet.Packets.IpV4;
using PcapDotNet.Packets.Transport;
namespace PcapDotNet.Core.Test
{
internal class WiresharkDatagramComparerUdp : WiresharkDatagramComparer
{
protected override string PropertyName
{
get { return "Udp"; }
}
protected override bool CompareField(XElement field, Datagram parentDatagram, Datagram datagram)
{
IpV4Datagram ipV4Datagram = (IpV4Datagram)parentDatagram;
UdpDatagram udpDatagram = (UdpDatagram)datagram;
switch (field.Name())
{
case "udp.srcport":
field.AssertShowDecimal(udpDatagram.SourcePort);
break;
case "udp.dstport":
field.AssertShowDecimal(udpDatagram.DestinationPort);
break;
case "udp.port":
Assert.IsTrue(ushort.Parse(field.Show()) == udpDatagram.SourcePort ||
ushort.Parse(field.Show()) == udpDatagram.DestinationPort);
break;
case "udp.length":
field.AssertShowDecimal(udpDatagram.TotalLength);
break;
case "udp.checksum":
field.AssertShowHex(udpDatagram.Checksum);
if (udpDatagram.Checksum != 0)
{
foreach (var checksumField in field.Fields())
{
switch (checksumField.Name())
{
case "udp.checksum_good":
checksumField.AssertShowDecimal(ipV4Datagram.IsTransportChecksumCorrect);
break;
case "udp.checksum_bad":
if (checksumField.Show() == "1")
Assert.IsFalse(ipV4Datagram.IsTransportChecksumCorrect);
else
checksumField.AssertShowDecimal(0);
break;
}
}
}
break;
case "udp.checksum_coverage":
field.AssertShowDecimal(udpDatagram.TotalLength);
break;
default:
throw new InvalidOperationException("Invalid udp field " + field.Name());
}
return true;
}
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment