コード例 #1
0
        public void ParseFullCSR1000VIPv4()
        {
            var parsed = CdpPacketParser.Parse(WiresharkCSR1000VIPv4);

            Assert.NotNull(parsed);

            Assert.Equal("csr.log.local", parsed.DeviceId);

            Assert.Equal("cisco CSR1000V", parsed.Platform);

            Assert.Single(parsed.Addresses);
            Assert.Equal(IPAddress.Parse("192.168.70.3"), parsed.Addresses[0]);

            Assert.Equal("GigabitEthernet2", parsed.PortId);

            Assert.True(parsed.HasCapabilities);
            Assert.True(parsed.CanRoute);
            Assert.False(parsed.CanTransparentBridge);
            Assert.False(parsed.CanSourceRouteBridge);
            Assert.False(parsed.CanSwitch);
            Assert.False(parsed.IsHost);
            Assert.True(parsed.IsIGMPCapable);
            Assert.False(parsed.IsRepeater);

            Assert.NotNull(parsed.OdrPrefixes);
            Assert.Single(parsed.OdrPrefixes);
            Assert.Equal(new IPPrefix {
                Network = IPAddress.Parse("172.24.30.160"), Length = 28
            }, parsed.OdrPrefixes[0]);

            Assert.Null(parsed.HelloProtocol);

            Assert.True(parsed.Duplex.HasValue);
            Assert.Equal(ECdpDuplex.Full, parsed.Duplex);
        }
コード例 #2
0
        public void ParseFull2960G()
        {
            var parsed = CdpPacketParser.Parse(WiresharkFrom2960G);

            Assert.NotNull(parsed);

            Assert.Equal("Acc1.nocturnal.local", parsed.DeviceId);

            Assert.Equal("cisco WS-C2960G-24TC-L", parsed.Platform);

            Assert.Single(parsed.Addresses);
            Assert.Equal(IPAddress.Parse("10.100.1.18"), parsed.Addresses[0]);

            Assert.Equal("GigabitEthernet0/7", parsed.PortId);

            Assert.True(parsed.HasCapabilities);
            Assert.False(parsed.CanRoute);
            Assert.False(parsed.CanTransparentBridge);
            Assert.False(parsed.CanSourceRouteBridge);
            Assert.True(parsed.CanSwitch);
            Assert.False(parsed.IsHost);
            Assert.True(parsed.IsIGMPCapable);
            Assert.False(parsed.IsRepeater);

            Assert.NotNull(parsed.HelloProtocol);
            Assert.Equal(0x00000C, parsed.HelloProtocol.Oui);
            Assert.Equal(PhysicalAddress.Parse("00-1E-F6-C1-78-00"), parsed.HelloProtocol.SwitchMac);

            Assert.NotNull(parsed.VtpManagementDomain);
            Assert.Empty(parsed.VtpManagementDomain);

            Assert.Equal(101, parsed.NativeVlan);

            Assert.True(parsed.Duplex.HasValue);
            Assert.Equal(ECdpDuplex.Full, parsed.Duplex.Value);

            Assert.True(parsed.TrustBitmap.HasValue);
            Assert.Equal(0, parsed.TrustBitmap);

            Assert.True(parsed.UntrustedPortCoS.HasValue);
            Assert.Equal(0, parsed.UntrustedPortCoS);

            Assert.Single(parsed.Addresses);
            Assert.Equal(IPAddress.Parse("10.100.1.18"), parsed.Addresses[0]);

            Assert.NotNull(parsed.PowerAvailable);
            Assert.Equal(0, parsed.PowerAvailable.RequestId);
            Assert.Equal(1, parsed.PowerAvailable.ManagementId);
            Assert.Equal(uint.MinValue, parsed.PowerAvailable.PowerAvailable);
            Assert.Equal(uint.MaxValue, parsed.PowerAvailable.PowerAvailable2);
        }
コード例 #3
0
        static void Main(string[] args)
        {
            // Find all Ethernet adapters on the machine.
            var ethernetInterfaces =
                from
                nic in NetworkInterface.GetAllNetworkInterfaces()
                where
                nic.OperationalStatus == OperationalStatus.Up &&
                nic.NetworkInterfaceType == NetworkInterfaceType.Ethernet ||
                nic.NetworkInterfaceType == NetworkInterfaceType.FastEthernetFx ||
                nic.NetworkInterfaceType == NetworkInterfaceType.FastEthernetT ||
                nic.NetworkInterfaceType == NetworkInterfaceType.GigabitEthernet
                select
                nic
            ;

            JsonSerializerSettings serializerSettings =
                new JsonSerializerSettings()
            {
                ContractResolver     = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver(),
                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
                NullValueHandling    = NullValueHandling.Ignore
            };

            serializerSettings.Converters.Add(new IPAddressConverter());
            serializerSettings.Converters.Add(new IPEndPointConverter());

            var tasks = new List <Task>();

            foreach (var nic in ethernetInterfaces)
            {
                Console.WriteLine("Starting CDP for interface " + nic.Name + " of type " + nic.NetworkInterfaceType.ToString());

                Task.Factory.StartNew(
                    async() =>
                {
                    var llcSocket = new LLCSocket(nic.GetPhysicalAddress());
                    llcSocket.RegisterMacOnInterface(nic.Name, CdpAddress);
                    while (true)
                    {
                        var packet       = llcSocket.ReceiveFrom(out PhysicalAddress remoteHost);
                        CdpPacket parsed = null;

                        try
                        {
                            Console.WriteLine("Parsing packet");
                            parsed = CdpPacketParser.Parse(packet);
                            Console.WriteLine("Packet parsed");
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Exception while parsing: " + e.Message);
                        }

                        if (parsed != null)
                        {
                            var message = new CdpApiMessage
                            {
                                ReceivedOn = nic.Name,
                                ReceivedAt = DateTimeOffset.Now,
                                SourceMac  = remoteHost.ToString(),
                                Packet     = parsed
                            };

                            var dataAsString            = JsonConvert.SerializeObject(message, serializerSettings);
                            var content                 = new StringContent(dataAsString);
                            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                            Console.WriteLine("Preparing to send packet");
                            Console.WriteLine("Sending " + dataAsString);
                            var client = new HttpClient();
                            await client.PostAsync("http://192.168.70.1:51954/api/cdp", content);
                            Console.WriteLine("Data sent");
                        }
                    }
                },
                    TaskCreationOptions.LongRunning
                    );
            }

            Console.WriteLine("Press any key to exit");
            Console.ReadKey();
        }