仿真平台内核初版 -tlib库 包含<sparc arm riscv powerPC>

lib/Packet.Net/PacketDotNet/ARPPacket.cs

@@ -0,0 +1,408 @@
+/*
+This file is part of PacketDotNet
+
+PacketDotNet is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+PacketDotNet is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with PacketDotNet.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+ *  Copyright 2011 Chris Morgan <chmorgan@gmail.com>
+ */
+using System;
+using System.Collections.Generic;
+using System.Net.NetworkInformation;
+using System.Text;
+using MiscUtil.Conversion;
+using PacketDotNet.Utils;
+
+namespace PacketDotNet
+{
+    /// <summary>
+    /// An ARP protocol packet.
+    /// </summary>
+    public class ARPPacket : InternetLinkLayerPacket
+    {
+        // NOTE: No need to warn about lack of use, the compiler won't
+        //       put any calls to 'log' here but we need 'log' to exist to compile
+#pragma warning disable 0169, 0649
+        private static readonly ILogInactive log;
+#pragma warning restore 0169, 0649
+
+        /// <value>
+        /// Also known as HardwareType
+        /// </value>
+        virtual public LinkLayers HardwareAddressType
+        {
+            get
+            {
+                return (LinkLayers)EndianBitConverter.Big.ToUInt16(header.Bytes,
+                                                                  header.Offset + ARPFields.HardwareAddressTypePosition);
+            }
+
+            set
+            {
+                var theValue = (UInt16)value;
+                EndianBitConverter.Big.CopyBytes(theValue,
+                                                 header.Bytes,
+                                                 header.Offset + ARPFields.HardwareAddressTypePosition);
+            }
+        }
+
+        /// <value>
+        /// Also known as ProtocolType
+        /// </value>
+        virtual public EthernetPacketType ProtocolAddressType
+        {
+            get
+            {
+                return (EthernetPacketType)EndianBitConverter.Big.ToUInt16(header.Bytes,
+                                                                           header.Offset + ARPFields.ProtocolAddressTypePosition);
+            }
+
+            set
+            {
+                var theValue = (UInt16)value;
+                EndianBitConverter.Big.CopyBytes(theValue,
+                                                 header.Bytes,
+                                                 header.Offset + ARPFields.ProtocolAddressTypePosition);
+            }
+        }
+
+        /// <value>
+        /// Hardware address length field
+        /// </value>
+        virtual public int HardwareAddressLength
+        {
+            get
+            {
+                return header.Bytes[header.Offset + ARPFields.HardwareAddressLengthPosition];
+            }
+
+            set
+            {
+                header.Bytes[header.Offset + ARPFields.HardwareAddressLengthPosition] = (byte)value;
+            }
+        }
+
+        /// <value>
+        /// Protocol address length field
+        /// </value>
+        virtual public int ProtocolAddressLength
+        {
+            get
+            {
+                return header.Bytes[header.Offset + ARPFields.ProtocolAddressLengthPosition];
+            }
+
+            set
+            {
+                header.Bytes[header.Offset + ARPFields.ProtocolAddressLengthPosition] = (byte)value;
+            }
+        }
+
+        /// <summary> Fetch the operation code.
+        /// Usually one of ARPFields.{ARP_OP_REQ_CODE, ARP_OP_REP_CODE}.
+        /// </summary>
+        /// <summary> Sets the operation code.
+        /// Usually one of ARPFields.{ARP_OP_REQ_CODE, ARP_OP_REP_CODE}.
+        /// </summary>
+        virtual public ARPOperation Operation
+        {
+            get
+            {
+                return (ARPOperation)EndianBitConverter.Big.ToInt16(header.Bytes,
+                                                                    header.Offset + ARPFields.OperationPosition);
+            }
+
+            set
+            {
+                var theValue = (Int16)value;
+                EndianBitConverter.Big.CopyBytes(theValue,
+                                                 header.Bytes,
+                                                 header.Offset + ARPFields.OperationPosition);
+            }
+        }
+
+        /// <value>
+        /// Upper layer protocol address of the sender, arp is used for IPv4, IPv6 uses NDP
+        /// </value>
+        virtual public System.Net.IPAddress SenderProtocolAddress
+        {
+            get
+            {
+                return IpPacket.GetIPAddress(System.Net.Sockets.AddressFamily.InterNetwork,
+                                             header.Offset + ARPFields.SenderProtocolAddressPosition,
+                                             header.Bytes);
+            }
+
+            set
+            {
+                // check that the address family is ipv4
+                if (value.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork)
+                    throw new System.InvalidOperationException("Family != IPv4, ARP is used for IPv4, NDP for IPv6");
+
+                byte[] address = value.GetAddressBytes();
+                Array.Copy(address, 0,
+                           header.Bytes, header.Offset + ARPFields.SenderProtocolAddressPosition,
+                           address.Length);
+            }
+        }
+
+        /// <value>
+        /// Upper layer protocol address of the target, arp is used for IPv4, IPv6 uses NDP
+        /// </value>
+        virtual public System.Net.IPAddress TargetProtocolAddress
+        {
+            get
+            {
+                return IpPacket.GetIPAddress(System.Net.Sockets.AddressFamily.InterNetwork,
+                                             header.Offset + ARPFields.TargetProtocolAddressPosition,
+                                             header.Bytes);
+            }
+
+            set
+            {
+                // check that the address family is ipv4
+                if (value.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork)
+                    throw new System.InvalidOperationException("Family != IPv4, ARP is used for IPv4, NDP for IPv6");
+
+                byte[] address = value.GetAddressBytes();
+                Array.Copy(address, 0,
+                           header.Bytes, header.Offset + ARPFields.TargetProtocolAddressPosition,
+                           address.Length);
+            }
+        }
+
+        /// <value>
+        /// Sender hardware address, usually an ethernet mac address
+        /// </value>
+        public virtual PhysicalAddress SenderHardwareAddress
+        {
+            get
+            {
+                //FIXME: this code is broken because it assumes that the address position is
+                // a fixed position
+                byte[] hwAddress = new byte[HardwareAddressLength];
+                Array.Copy(header.Bytes, header.Offset + ARPFields.SenderHardwareAddressPosition,
+                           hwAddress, 0, hwAddress.Length);
+                return new PhysicalAddress(hwAddress);
+            }
+
+            set
+            {
+                byte[] hwAddress = value.GetAddressBytes();
+
+                // for now we only support ethernet addresses even though the arp protocol
+                // makes provisions for varying length addresses
+                if(hwAddress.Length != EthernetFields.MacAddressLength)
+                {
+                    throw new System.InvalidOperationException("expected physical address length of "
+                                                               + EthernetFields.MacAddressLength
+                                                               + " but it was "
+                                                               + hwAddress.Length);
+                }
+
+                Array.Copy(hwAddress, 0,
+                           header.Bytes, header.Offset + ARPFields.SenderHardwareAddressPosition,
+                           hwAddress.Length);
+            }
+        }
+
+        /// <value>
+        /// Target hardware address, usually an ethernet mac address
+        /// </value>
+        public virtual PhysicalAddress TargetHardwareAddress
+        {
+            get
+            {
+                //FIXME: this code is broken because it assumes that the address position is
+                // a fixed position
+                byte[] hwAddress = new byte[HardwareAddressLength];
+                Array.Copy(header.Bytes, header.Offset + ARPFields.TargetHardwareAddressPosition,
+                           hwAddress, 0,
+                           hwAddress.Length);
+                return new PhysicalAddress(hwAddress);
+            }
+            set
+            {
+                byte[] hwAddress = value.GetAddressBytes();
+
+                // for now we only support ethernet addresses even though the arp protocol
+                // makes provisions for varying length addresses
+                if(hwAddress.Length != EthernetFields.MacAddressLength)
+                {
+                    throw new System.InvalidOperationException("expected physical address length of "
+                                                               + EthernetFields.MacAddressLength
+                                                               + " but it was "
+                                                               + hwAddress.Length);
+                }
+
+                Array.Copy(hwAddress, 0,
+                           header.Bytes, header.Offset + ARPFields.TargetHardwareAddressPosition,
+                           hwAddress.Length);
+            }
+        }
+
+        /// <summary> Fetch ascii escape sequence of the color associated with this packet type.</summary>
+        override public System.String Color
+        {
+            get
+            {
+                return AnsiEscapeSequences.Purple;
+            }
+        }
+
+        /// <summary>
+        /// Create an ARPPacket from values
+        /// </summary>
+        /// <param name="Operation">
+        /// A <see cref="ARPOperation"/>
+        /// </param>
+        /// <param name="TargetHardwareAddress">
+        /// A <see cref="PhysicalAddress"/>
+        /// </param>
+        /// <param name="TargetProtocolAddress">
+        /// A <see cref="System.Net.IPAddress"/>
+        /// </param>
+        /// <param name="SenderHardwareAddress">
+        /// A <see cref="PhysicalAddress"/>
+        /// </param>
+        /// <param name="SenderProtocolAddress">
+        /// A <see cref="System.Net.IPAddress"/>
+        /// </param>
+        public ARPPacket(ARPOperation Operation,
+                         PhysicalAddress TargetHardwareAddress,
+                         System.Net.IPAddress TargetProtocolAddress,
+                         PhysicalAddress SenderHardwareAddress,
+                         System.Net.IPAddress SenderProtocolAddress)
+        {
+            log.Debug("");
+
+            // allocate memory for this packet
+            int offset = 0;
+            int length = ARPFields.HeaderLength;
+            var headerBytes = new byte[length];
+            header = new ByteArraySegment(headerBytes, offset, length);
+
+            this.Operation = Operation;
+            this.TargetHardwareAddress = TargetHardwareAddress;
+            this.TargetProtocolAddress = TargetProtocolAddress;
+            this.SenderHardwareAddress = SenderHardwareAddress;
+            this.SenderProtocolAddress = SenderProtocolAddress;
+
+            // set some internal properties to fully define the packet
+            this.HardwareAddressType = LinkLayers.Ethernet;
+            this.HardwareAddressLength = EthernetFields.MacAddressLength;
+
+            this.ProtocolAddressType = EthernetPacketType.IpV4;
+            this.ProtocolAddressLength = IPv4Fields.AddressLength;
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="bas">
+        /// A <see cref="ByteArraySegment"/>
+        /// </param>
+        public ARPPacket(ByteArraySegment bas)
+        {
+            header = new ByteArraySegment(bas);
+            RandomUtils.EnsurePacketLength(this, ARPFields.HeaderLength, header.Length);
+            header.Length = ARPFields.HeaderLength;
+
+            // NOTE: no need to set the payloadPacketOrData field, arp packets have
+            //       no payload
+        }
+
+        /// <summary cref="Packet.ToString(StringOutputType)" />
+        public override string ToString(StringOutputType outputFormat)
+        {
+            var buffer = new StringBuilder();
+            string color = "";
+            string colorEscape = "";
+
+            if(outputFormat == StringOutputType.Colored || outputFormat == StringOutputType.VerboseColored)
+            {
+                color = Color;
+                colorEscape = AnsiEscapeSequences.Reset;
+            }
+
+            if(outputFormat == StringOutputType.Normal || outputFormat == StringOutputType.Colored)
+            {
+                // build the output string
+                buffer.AppendFormat("{0}[ARPPacket: Operation={2}, SenderHardwareAddress={3}, TargetHardwareAddress={4}, SenderProtocolAddress={5}, TargetProtocolAddress={6}]{1}",
+                    color,
+                    colorEscape,
+                    Operation,
+                    HexPrinter.PrintMACAddress(SenderHardwareAddress),
+                    HexPrinter.PrintMACAddress(TargetHardwareAddress),
+                    SenderProtocolAddress,
+                    TargetProtocolAddress);
+            }
+
+            if(outputFormat == StringOutputType.Verbose || outputFormat == StringOutputType.VerboseColored)
+            {
+                // collect the properties and their value
+                Dictionary<string,string> properties = new Dictionary<string,string>();
+                properties.Add("hardware type", HardwareAddressType.ToString() + " (0x" + HardwareAddressType.ToString("x") + ")");
+                properties.Add("protocol type", ProtocolAddressType.ToString() + " (0x" + ProtocolAddressType.ToString("x") + ")");
+                properties.Add("operation", Operation.ToString() + " (0x" + Operation.ToString("x") + ")");
+                properties.Add("source hardware address", HexPrinter.PrintMACAddress(SenderHardwareAddress));
+                properties.Add("destination hardware address", HexPrinter.PrintMACAddress(TargetHardwareAddress));
+                properties.Add("source protocol address", SenderProtocolAddress.ToString());
+                properties.Add("destination protocol address", TargetProtocolAddress.ToString());
+
+                // calculate the padding needed to right-justify the property names
+                int padLength = Utils.RandomUtils.LongestStringLength(new List<string>(properties.Keys));
+
+                // build the output string
+                buffer.AppendLine("ARP:  ******* ARP - \"Address Resolution Protocol\" - offset=? length=" + TotalPacketLength);
+                buffer.AppendLine("ARP:");
+                foreach(var property in properties)
+                {
+                    buffer.AppendLine("ARP: " + property.Key.PadLeft(padLength) + " = " + property.Value);
+                }
+                buffer.AppendLine("ARP:");
+            }
+
+            // append the base string output
+            buffer.Append(base.ToString(outputFormat));
+
+            return buffer.ToString();
+        }
+
+        /// <summary>
+        /// Returns the encapsulated ARPPacket of the Packet p or null if
+        /// there is no encapsulated packet
+        /// </summary>
+        /// <param name="p">
+        /// A <see cref="Packet"/>
+        /// </param>
+        /// <returns>
+        /// A <see cref="ARPPacket"/>
+        /// </returns>
+        [Obsolete("Use Packet.Extract() instead")]
+        public static ARPPacket GetEncapsulated(Packet p)
+        {
+            if(p is InternetLinkLayerPacket)
+            {
+                var payload = InternetLinkLayerPacket.GetInnerPayload((InternetLinkLayerPacket)p);
+                if(payload is ARPPacket)
+                {
+                    return (ARPPacket)payload;
+                }
+            }
+
+            return null;
+        }
+    }
+}