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