public void SetComboBoxSelectedIndex(IPProtocol.IPProtocolType ipProtocolType)
{
for (int i = 0; i < comboBoxIPProtocols.Items.Count; i++)
{
object item = comboBoxIPProtocols.Items[i];
if ((IPProtocol.IPProtocolType)((DictionaryEntry)item).Key == ipProtocolType)
{
comboBoxIPProtocols.SelectedIndex = i;
break;
}
}
}
/// <summary> Convert captured packet data into an object.</summary>
public static Packet dataToPacket(int linkType, byte[] bytes, Timeval tv)
{
int ethProtocol;
// retrieve the length of the headers associated with this link layer type.
// this length is the offset to the header embedded in the packet.
int lLen = LinkLayer.getLinkLayerLength(linkType);
// extract the protocol code for the type of header embedded in the
// link-layer of the packet
int offset = LinkLayer.getProtoOffset(linkType);
if (offset == -1)
{
// if there is no embedded protocol, assume IP?
ethProtocol = EthernetPacket.EtherType.IP;
}
else
{
ethProtocol = ArrayHelper.extractInteger(bytes, offset, EthernetFields_Fields.ETH_CODE_LEN);
}
// try to recognize the ethernet type..
switch (ethProtocol)
{
// arp
case EthernetPacket.EtherType.ARP:
return(new ARPPacket(lLen, bytes, tv));
case EthernetPacket.EtherType.IPV6:
case EthernetPacket.EtherType.IP:
// ethernet level code is recognized as IP, figure out what kind..
int ipProtocol = IPProtocol.extractProtocol(lLen, bytes);
switch (ipProtocol)
{
case (int)IPProtocol.IPProtocolType.ICMP: return(new ICMPPacket(lLen, bytes, tv));
case (int)IPProtocol.IPProtocolType.IGMP: return(new IGMPPacket(lLen, bytes, tv));
case (int)IPProtocol.IPProtocolType.TCP: return(new TCPPacket(lLen, bytes, tv));
case (int)IPProtocol.IPProtocolType.UDP: return(new UDPPacket(lLen, bytes, tv));
// unidentified ip..
default:
return(new IPPacket(lLen, bytes, tv));
}
// ethernet level code not recognized, default to anonymous packet..
default:
return(new EthernetPacket(lLen, bytes, tv));
}
}
public IPPacket(IPVersions ipVersion,
IPProtocol.IPProtocolType ipProtocolType,
IPAddress sourceAddress,
IPAddress destinationAddress,
EthernetPacket ethernetPacket,
byte[] ipPacketPayload)
: base(EthernetFields_Fields.ETH_HEADER_LEN, null)
{
// determine how many bytes we need for this packet
int ipHeaderLength = ((ipVersion == IPVersions.IPv4) ? IPv4Fields_Fields.IP_HEADER_LEN : IPv6Fields_Fields.IPv6_HEADER_LEN);
int ipPayloadLength = (ipPacketPayload != null) ? ipPacketPayload.Length : 0;
int totalBytesRequired = 0;
totalBytesRequired += EthernetFields_Fields.ETH_HEADER_LEN;
totalBytesRequired += ipHeaderLength;
totalBytesRequired += ipPayloadLength;
// copy the ethernet packet header into the byte array
byte[] bytes = new Byte[totalBytesRequired];
Array.Copy(ethernetPacket.EthernetHeader, bytes, ethernetPacket.EthernetHeader.Length);
// set the packet bytes to our new, correct length
// buffer
//
// NOTE: we cannot say: Bytes = bytes; because
// the Bytes set property results in a call to
// InitIPPacket with a parameter of IPVersion which
// would result in the version being retrieved from
// an offset into the byte array but we haven't
// set the version in the byte array yet by setting
// this.IPVersion to a value
base.Bytes = bytes;
// call InitIPPacket to instantiate a packet of the proper type
InitIPPacket(ipVersion);
// set the header length to the default value for our ip version
IPHeaderLength = ipHeaderLength;
// set the EthernetPacket type to the proper ip version
base.EthernetProtocol = (ipVersion == IPVersions.IPv4) ? EthernetPacketType.IPv4 : EthernetPacketType.IPv6;
// set the ip protocol type
this.IPProtocol = ipProtocolType;
// set the current instance to the proper ip version
this.IPVersion = ipVersion;
// update the source and destination addresses
this.SourceAddress = sourceAddress;
this.DestinationAddress = destinationAddress;
// and set the payload to the payload that was passed in
if (ipPacketPayload != null)
{
Array.Copy(ipPacketPayload, 0, Bytes, _ipPayloadOffset, ipPacketPayload.Length);
IPPayloadLength = ipPacketPayload.Length;
}
else
{
IPPayloadLength = 0;
}
}
/// <summary> Convert captured packet data into an object.</summary>
public static Packet dataToPacket(LinkLayers linkType, byte[] bytes, Timeval tv)
{
EthernetPacketType ethProtocol;
// retrieve the length of the headers associated with this link layer type.
// this length is the offset to the header embedded in the packet.
int byteOffsetToEthernetPayload = LinkLayer.LinkLayerLength(linkType);
// extract the protocol code for the type of header embedded in the
// link-layer of the packet
int offset = LinkLayer.ProtocolOffset(linkType);
if (offset == -1)
{
// if there is no embedded protocol, assume IpV4
ethProtocol = EthernetPacketType.IPv4;
}
else
{
ethProtocol = (EthernetPacketType)ArrayHelper.extractInteger(bytes, offset, EthernetFields_Fields.ETH_CODE_LEN);
}
string errorString;
Packet parsedPacket = null;
try
{
// try to recognize the ethernet type..
switch (ethProtocol)
{
// arp
case EthernetPacketType.ARP:
parsedPacket = new ARPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
case EthernetPacketType.IPv6:
case EthernetPacketType.IPv4:
try
{
// ethernet level code is recognized as IP, figure out what kind..
int ipProtocol = IPProtocol.extractProtocol(byteOffsetToEthernetPayload, bytes);
switch (ipProtocol)
{
case (int)IPProtocol.IPProtocolType.ICMP:
parsedPacket = new ICMPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
case (int)IPProtocol.IPProtocolType.IGMP:
parsedPacket = new IGMPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
case (int)IPProtocol.IPProtocolType.TCP:
parsedPacket = new TCPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
case (int)IPProtocol.IPProtocolType.UDP:
parsedPacket = new UDPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
// unidentified ip..
default:
parsedPacket = new IPPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
}
// check that the parsed packet is valid
if (!parsedPacket.IsValid(out errorString))
{
throw new PcapException(errorString);
}
else
{
return(parsedPacket);
}
}
catch
{
// error parsing the specific ip packet type, parse as a generic IPPacket
parsedPacket = new IPPacket(byteOffsetToEthernetPayload, bytes, tv);
// check that the parsed packet is valid
if (!parsedPacket.IsValid(out errorString))
{
throw new PcapException(errorString);
}
else
{
return(parsedPacket);
}
}
// ethernet level code not recognized, default to anonymous packet..
default:
parsedPacket = new EthernetPacket(byteOffsetToEthernetPayload, bytes, tv);
break;
}
return(parsedPacket);
}
catch
{
// we know we have at least an ethernet packet, so return that
return(new EthernetPacket(byteOffsetToEthernetPayload, bytes, tv));
}
}