C# PhysicalAddress.GetHashCode方法代码示例

		public void GetHashCodeNotEqual()
		{
			PhysicalAddress phys1 = new PhysicalAddress(new byte[] { 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 });
			PhysicalAddress phys2 = new PhysicalAddress(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 });

			Assert.IsFalse(phys1.GetHashCode().Equals(phys2.GetHashCode()));
		}

        public void injectRemotePacket(ref byte[] data, PhysicalAddress dstMAC, PhysicalAddress srcMAC, ref xbs_node sending_node)
        {
            Packet p = null;
            ARPPacket p_arp = null;
            IPv4Packet p_ipv4 = null;
            ICMPv4Packet p_icmp = null;
            UdpPacket p_udp = null;
            TcpPacket p_tcp = null;

            IPAddress source_IP = null;

            int srcMac_hash = srcMAC.GetHashCode();
            // collect all injected source MACs. sniffer needs this to filter packets out
            lock (injected_macs_hash)
            {
                if (!injected_macs_hash.Contains(srcMac_hash))
                {
                    injected_macs_hash.Add(srcMac_hash);
                    addMacToKnownMacListFromRemoteNodes(srcMAC);
                }
            }

            if (sending_node != null)
                if (sending_node.addXbox(srcMAC))
                    node_list.listHasJustChanged();

            try
            {
                p = Packet.ParsePacket(LinkLayers.Ethernet, data);
            }
            catch (PcapException pcex)
            {
#if DEBUG
                xbs_messages.addDebugMessage("!! ERROR! parse packet failed in injectRemotePacket (1): " + pcex.ToString(), xbs_message_sender.SNIFFER, xbs_message_type.ERROR);
#endif
                return;
            }
            catch (NotImplementedException niex)
            {
#if DEBUG
                xbs_messages.addDebugMessage("!! ERROR! parse packet failed in injectRemotePacket (2): " + niex.ToString(), xbs_message_sender.SNIFFER, xbs_message_type.ERROR);
#endif
                return;
            }

            // DETERMINE PACKET TYPE
            if (p.PayloadPacket is IPv4Packet)
            {
                p_ipv4 = p.PayloadPacket as IPv4Packet;
                source_IP = p_ipv4.SourceAddress;
                if (p_ipv4.PayloadPacket is UdpPacket)
                    p_udp = p_ipv4.PayloadPacket as UdpPacket;
                else if (p_ipv4.PayloadPacket is TcpPacket)
                    p_tcp = p_ipv4.PayloadPacket as TcpPacket;
            }
            else if (p.PayloadPacket is ARPPacket)
            {
                p_arp = p.PayloadPacket as ARPPacket;
                source_IP = p_arp.SenderProtocolAddress;            
            }
            else if (p.PayloadPacket is ICMPv4Packet)
                p_icmp = p.PayloadPacket as ICMPv4Packet;
            else
            {
                // UNKNOWN OR UNSUPPORTED PACKET TYPE
#if DEBUG
                //xbs_messages.addDebugMessage("?? WARNING! unknown incoming packet type: " + p.ToString(), xbs_message_sender.SNIFFER, xbs_message_type.WARNING);
#endif
                return;
            }

            // filter packet if needed
            if (is_injected_packet_to_be_filtered(ref p_arp, ref p_ipv4, ref p_udp, ref p_tcp))
            {
#if DEBUG
                xbs_messages.addDebugMessage("i> filtered packet: " + p, xbs_message_sender.SNIFFER);
#endif
                return;
            }

            // add IP to device from node
            if (sending_node != null && source_IP!=null)
                if (sending_node.addIPtoXbox(srcMAC, source_IP))
                {
#if DEBUG
                    xbs_messages.addDebugMessage("i> added new IP "+source_IP+" to xbox "+srcMAC+" for node " + sending_node, xbs_message_sender.SNIFFER);
#endif
                    node_list.listHasJustChanged();
                }

#if DEBUG
            xbs_messages.addDebugMessage("i> " + p, xbs_message_sender.SNIFFER);
#endif
            if (NAT.NAT_enabled)
            {
#if DEBUG
                System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
                stopWatch.Start();
#endif
                EthernetPacketType p_type = NAT.NAT_incoming_packet_PacketDotNet(ref data, dstMAC, srcMAC, ref p, ref p_ipv4, ref p_arp);
//.........这里部分代码省略.........

		public void GetHashCodeEqual()
		{
			PhysicalAddress phys1 = new PhysicalAddress(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 });
			PhysicalAddress phys2 = new PhysicalAddress(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 });

			Assert.AreEqual(phys1.GetHashCode(), phys2.GetHashCode());
		}

        public void dispatch_packet(ref RawCapture rawPacket)
        {
            byte[] src_mac = new byte[6];
            byte[] dst_mac = new byte[6];
            byte[] packet_data = rawPacket.Data;

            // copy source and destination MAC addresses from sniffed packet
            Buffer.BlockCopy(rawPacket.Data, 0, dst_mac, 0, 6);
            PhysicalAddress dstMAC = new PhysicalAddress(dst_mac);
            Buffer.BlockCopy(rawPacket.Data, 6, src_mac, 0, 6);
            PhysicalAddress srcMAC = new PhysicalAddress(src_mac);

#if DEBUG
            xbs_messages.addDebugMessage("s> " + srcMAC + "=>" + dstMAC + "Len:" + rawPacket.Data.Length, xbs_message_sender.SNIFFER);
            Packet p = Packet.ParsePacket(rawPacket.LinkLayerType, rawPacket.Data);
            xbs_messages.addDebugMessage("s> " + p, xbs_message_sender.SNIFFER);
#endif

            // if sniffed packet has MAC of packet we injected, discard
            bool is_injected_packet = false;
            lock (injected_macs_hash)
                is_injected_packet = injected_macs_hash.Contains(srcMAC.GetHashCode());
            if (is_injected_packet) 
                return;

            if (NAT.NAT_enabled)
            {
#if DEBUG
                System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
                stopWatch.Start();
#endif
                EthernetPacketType p_type = NAT.deNAT_outgoing_packet_PacketDotNet(ref packet_data, dstMAC, srcMAC);
#if DEBUG
                stopWatch.Stop();
                if (p_type == EthernetPacketType.IpV4)
                {
                    xbs_sniffer_statistics.deNAT_callCount++;
                    if (xbs_sniffer_statistics.deNAT_callCount > 1)
                    {
                        xbs_sniffer_statistics.deNAT_timeInCode += (UInt64)stopWatch.ElapsedTicks;
                        UInt32 average = (UInt32)(xbs_sniffer_statistics.deNAT_timeInCode / (xbs_sniffer_statistics.deNAT_callCount - 1));
                        double average_ms = new TimeSpan(average).TotalMilliseconds;
                        xbs_messages.addDebugMessage("- deNAT time: " + stopWatch.ElapsedTicks + " deNAT count: " + (xbs_sniffer_statistics.deNAT_callCount - 1) + " Total Time: " + xbs_sniffer_statistics.deNAT_timeInCode + "=> " + average + " / " + average_ms + "ms", xbs_message_sender.SNIFFER);
                    }
                }
                p = Packet.ParsePacket(rawPacket.LinkLayerType, packet_data);
                xbs_messages.addDebugMessage("s> " + p, xbs_message_sender.SNIFFER);
#endif
            }

            // count the sniffed packets from local xboxs
            xbs_sniffer_statistics.packet_count++;

            // find node with destination MAC Address in network and send packet
            xbs_node node = node_list.distributeDataPacket(dstMAC, packet_data);

            int srcMac_hash = srcMAC.GetHashCode();
            bool pdevfilter_needs_change = false;
            lock (sniffed_macs_hash)
            {
                if (!sniffed_macs_hash.Contains(srcMac_hash))
                {
                    sniffed_macs_hash.Add(srcMac_hash);
                    lock (sniffed_macs)
                        sniffed_macs.Add(srcMAC);
                    pdevfilter_needs_change = true;
                }
            }
            if (pdevfilter_needs_change)
                setPdevFilter();
        }

 public xbs_xbox(PhysicalAddress phy)
 {
     mac = phy;
     hash = mac.GetHashCode();
 }

 public bool addIPtoXbox(PhysicalAddress mac, IPAddress ip)
 {
     int hash = mac.GetHashCode();
     lock (this)
     {
         foreach (xbs_xbox xbox in xbox_list)
             if (hash == xbox.hash)
                 return xbox.addIPAddress(ip);
     }
     return false;
 }

 public bool addXbox(PhysicalAddress mac)
 {
     int hash = mac.GetHashCode();
     bool xbox_found = false;
     lock (this)
     {
         foreach (xbs_xbox xbox in xbox_list)
             if (hash == xbox.hash)
                 xbox_found = true;
         if (!xbox_found)
             xbox_list.Add(new xbs_xbox(mac));
     }
     if (!xbox_found)
     {
         xbs_messages.addInfoMessage(" ~ added new device " + mac + " for node " + this, xbs_message_sender.NODE);
         changed();
     }
     return (!xbox_found);
 }

 public bool has_xbox(PhysicalAddress xbox_addr)
 {
     if (xbox_addr.Equals(xbs_nat.broadcast_mac) || xbox_addr.Equals(xbs_nat.zero_mac))
         return true;
     int hash = xbox_addr.GetHashCode();
     bool ret = false;
     lock (this)
     {
         foreach (xbs_xbox xbox in xbox_list)
             if (xbox.hash == hash)
                 ret = true;
     }
     return ret;
 }