Exemple #1
0
        public override IEnumerable <AbstractPacket> GetSubPackets(bool includeSelfReference)
        {
            if (includeSelfReference)
            {
                yield return(this);
            }
            AbstractPacket packet = null;

            try {
                if (this.dsap == (byte)ServiceAccessPointType.SubNetworkAccessProtocol)
                {
                    if (PacketStartIndex + 8 < PacketEndIndex)
                    {
                        if (this.etherType == (ushort)Ethernet2Packet.EtherTypes.IPv4)//IPv4
                        //packet=new IPv4Packet(this.ParentFrame, PacketStartIndex+8, PacketEndIndex);
                        {
                            IPv4Packet.TryParse(this.ParentFrame, PacketStartIndex + 8, PacketEndIndex, out packet);
                        }
                        else if (this.etherType == (ushort)Ethernet2Packet.EtherTypes.ARP)//ARP
                        //packet=new Ethernet2Packet(this.ParentFrame, PacketStartIndex+8, PacketEndIndex);
                        {
                            packet = new ArpPacket(this.ParentFrame, PacketStartIndex + 8, PacketEndIndex);
                        }
                        else
                        {
                            packet = new RawPacket(this.ParentFrame, PacketStartIndex + 8, PacketEndIndex);
                        }
                    }
                }
                else if (this.dsap == (byte)ServiceAccessPointType.HpExtendedLLC && this.etherType == (ushort)Ethernet2Packet.EtherTypes.HPSW)
                {
                    if (PacketStartIndex + 10 < PacketEndIndex)
                    {
                        //skip HP Extended LLC positions...
                        packet = new HpSwitchProtocolPacket(this.ParentFrame, PacketStartIndex + 3 + 3 + 2 + 2, PacketEndIndex);
                    }
                }
                else  //Not 802.2 SNAP or HPSW
                {
                    if (PacketStartIndex + 3 < PacketEndIndex)
                    {
                        packet = new RawPacket(this.ParentFrame, PacketStartIndex + 3, PacketEndIndex);
                    }
                }
            }
            catch (Exception e) {
                //packet=new RawPacket(this.ParentFrame, PacketStartIndex+14, PacketEndIndex);
                SharedUtils.Logger.Log("Exception when parsing inner packet of LLC: " + e.Message, SharedUtils.Logger.EventLogEntryType.Error);
                packet = new RawPacket(this.ParentFrame, PacketStartIndex + 3, PacketEndIndex);
            }
            if (packet != null)
            {
                yield return(packet);

                foreach (AbstractPacket subPacket in packet.GetSubPackets(false))
                {
                    yield return(subPacket);
                }
            }
        }
Exemple #2
0
        internal static AbstractPacket GetPacketForType(ushort etherType, Frame parentFrame, int newPacketStartIndex, int newPacketEndIndex)
        {
            AbstractPacket packet;

            try {
                //if(this.ParentFrame.Data[PacketStartIndex+12]==0x08 && this.ParentFrame.Data[PacketStartIndex+13]==0x00) {
                if (etherType == (ushort)Ethernet2Packet.EtherTypes.IPv4 && IPv4Packet.TryParse(parentFrame, newPacketStartIndex, newPacketEndIndex, out packet))
                {
                    //IPv4 packet
                    //packet = new IPv4Packet(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.IPv6)
                {
                    //IPv6 packet
                    packet = new IPv6Packet(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
                //else if(this.ParentFrame.Data[PacketStartIndex+12]==0x08 && this.ParentFrame.Data[PacketStartIndex+13]==0x06) {
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.ARP)
                {
                    packet = new ArpPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
                    //ARP-packet
                }
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.IEEE802_1Q)
                {
                    //VLAN
                    packet = new IEEE_802_1Q_VlanPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.MPLS)
                {
                    packet = new Mpls(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.PPPoE)
                {
                    packet = new PointToPointOverEthernetPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
                else if (etherType == (ushort)Ethernet2Packet.EtherTypes.xHayesTunnel)
                {
                    packet = new Ethernet2Packet(parentFrame, newPacketStartIndex + 4, newPacketEndIndex);
                }
                //etherType might actually be a content length if it is an IEEE 802.3 packet
                else if (etherType < 0x0600)
                {
                    //the etherType showed to actually be a length value
                    packet = new LogicalLinkControlPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }

                else
                {
                    //something else
                    packet = new RawPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
                }
            }
            catch (Exception) {
                packet = new RawPacket(parentFrame, newPacketStartIndex, newPacketEndIndex);
            }
            return(packet);
        }
Exemple #3
0
        public override IEnumerable <AbstractPacket> GetSubPackets(bool includeSelfReference)
        {
            //same as for Ethernet2Packet.cs

            if (includeSelfReference)
            {
                yield return(this);
            }
            if (PacketStartIndex + 16 < PacketEndIndex)
            {
                AbstractPacket packet;
                if (this.protocol == (ushort)Ethernet2Packet.EtherTypes.IPv4 && IPv4Packet.TryParse(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex, out packet))
                {
                    //IPv4 packet
                    //packet=new IPv4Packet(this.ParentFrame, PacketStartIndex+16, PacketEndIndex);
                }
                else if (this.protocol == (ushort)Ethernet2Packet.EtherTypes.IPv6)
                {
                    //IPv6 packet
                    packet = new IPv6Packet(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                }
                //else if(this.ParentFrame.Data[PacketStartIndex+12]==0x08 && this.ParentFrame.Data[PacketStartIndex+13]==0x06) {
                else if (this.protocol == (ushort)Ethernet2Packet.EtherTypes.ARP)
                {
                    packet = new ArpPacket(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                    //ARP-packet
                }
                else if (this.protocol == (ushort)Ethernet2Packet.EtherTypes.IEEE802_1Q)
                {
                    //VLAN
                    packet = new IEEE_802_1Q_VlanPacket(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                }
                else if (this.protocol == (ushort)Ethernet2Packet.EtherTypes.PPPoE)
                {
                    packet = new PointToPointOverEthernetPacket(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                }
                //etherType might actually be a content length if it is an IEEE 802.3 packet
                else if (this.protocol < 0x0600)
                {
                    //the etherType showed to actually be a length value
                    packet = new LogicalLinkControlPacket(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                }
                else
                {
                    //something else
                    packet = new RawPacket(this.ParentFrame, PacketStartIndex + 16, PacketEndIndex);
                }
                yield return(packet);

                foreach (AbstractPacket subPacket in packet.GetSubPackets(false))
                {
                    yield return(subPacket);
                }
            }
        }
        public override IEnumerable <AbstractPacket> GetSubPackets(bool includeSelfReference)
        {
            //throw new Exception("The method or operation is not implemented.");
            if (includeSelfReference)
            {
                yield return(this);
            }
            if (PacketStartIndex + 4 < PacketEndIndex && this.protocolCode != null)//there is room for data
            {
                AbstractPacket packet;
                //check the protocolCode
                if (this.protocolCode.Value == (ushort)Ethernet2Packet.EtherTypes.IPv4 && IPv4Packet.TryParse(ParentFrame, PacketStartIndex + 4, PacketEndIndex, out packet))
                {
                    //packet =new IPv4Packet(ParentFrame, PacketStartIndex+4, PacketEndIndex);
                }
                else if (this.protocolCode.Value == (ushort)Ethernet2Packet.EtherTypes.IPv6)
                {
                    packet = new IPv6Packet(ParentFrame, PacketStartIndex + 4, PacketEndIndex);
                }
                else if (this.protocolCode.Value == (ushort)Ethernet2Packet.EtherTypes.ARP)//not sure if ARP packets are used inside cHDLC frames
                {
                    packet = new ArpPacket(ParentFrame, PacketStartIndex + 4, PacketEndIndex);
                }
                else if (this.protocolCode.Value == (ushort)Ethernet2Packet.EtherTypes.IEEE802_1Q)
                {
                    //VLAN
                    packet = new IEEE_802_1Q_VlanPacket(ParentFrame, PacketStartIndex + 4, PacketEndIndex);
                }
                else if (this.protocolCode.Value == (ushort)Ethernet2Packet.EtherTypes.PPPoE)
                {
                    packet = new PointToPointOverEthernetPacket(ParentFrame, PacketStartIndex + 4, PacketEndIndex);
                }
                else
                {
                    //something else
                    packet = new RawPacket(ParentFrame, PacketStartIndex + 4, PacketEndIndex);
                }
                yield return(packet);

                foreach (AbstractPacket subPacket in packet.GetSubPackets(false))
                {
                    yield return(subPacket);
                }
            }
        }