public void ArePropertiesAndValuesValid(String ipAddress, Byte subnetmaskLength, Boolean shouldBeValid) { IPv6Address address = IPv6Address.FromString(ipAddress); IPv6SubnetMask mask = new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(subnetmaskLength)); Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); serializerMock.Setup(x => x.Deserialze <IPv6Address>(ipAddress)).Returns(address).Verifiable(); serializerMock.Setup(x => x.Deserialze <IPv6SubnetMask>(subnetmaskLength.ToString())).Returns(mask).Verifiable(); var resolver = new DHCPv6RelayAgentSubnetResolver(); Boolean actual = resolver.ArePropertiesAndValuesValid(new Dictionary <String, String> { { "NetworkAddress", ipAddress }, { "SubnetMask", subnetmaskLength.ToString() }, }, serializerMock.Object); Assert.Equal(shouldBeValid, actual); serializerMock.Verify(); }
public async Task Handle(Boolean storageResult) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, IPv6Address.FromString("fe80::3"), IPv6Address.FromString("fe80::4"), Array.Empty <DHCPv6PacketOption>(), DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.Unkown, new List <DHCPv6PacketOption>())); Mock <IDHCPv6StorageEngine> storageEngineMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict); storageEngineMock.Setup(x => x.LogInvalidDHCPv6Packet(packet)).ReturnsAsync(storageResult); InvalidDHCPv6PacketArrivedMessageHandler handler = new InvalidDHCPv6PacketArrivedMessageHandler( storageEngineMock.Object, Mock.Of <ILogger <InvalidDHCPv6PacketArrivedMessageHandler> >()); await handler.Handle(new InvalidDHCPv6PacketArrivedMessage(packet), CancellationToken.None); storageEngineMock.Verify(); }
public static DHCPv6PacketIdentityAssociationAddressSuboption FromByteArray(Byte[] data, Int32 offset) { UInt16 lenght = ByteHelper.ConvertToUInt16FromByte(data, offset + 2); IPv6Address address = IPv6Address.FromByteArray(data, offset + 4); UInt32 preferredLifetime = ByteHelper.ConvertToUInt32FromByte(data, offset + 4 + 16); UInt32 validLifetime = ByteHelper.ConvertToUInt32FromByte(data, offset + 4 + 16 + 4); List <DHCPv6PacketSuboption> suboptions = new List <DHCPv6PacketSuboption>(); if (lenght > 16 + 4 + 4) { Byte[] subOptionsData = ByteHelper.CopyData(data, offset + 4 + 16 + 4 + 4); suboptions.AddRange(DHCPv6PacketSuboptionFactory.GetOptions(subOptionsData)); } return(new DHCPv6PacketIdentityAssociationAddressSuboption( address, TimeSpan.FromSeconds(preferredLifetime), TimeSpan.FromSeconds(validLifetime), suboptions)); }
public void GetRelayPacketChain() { IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); Int32 depth = 10; DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.REPLY, Array.Empty <DHCPv6PacketOption>());; for (int i = 0; i < depth; i++) { DHCPv6RelayPacket outerPacket = DHCPv6RelayPacket.AsInnerRelay( true, 1, IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); innerPacket = outerPacket; } DHCPv6RelayPacket inputPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, 1, IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); var chain = inputPacket.GetRelayPacketChain(); Assert.NotEmpty(chain); Assert.Equal(depth + 1, chain.Count); Assert.NotEqual(DHCPv6PacketTypes.RELAY_FORW, chain[0].InnerPacket.PacketType); Assert.NotEqual(DHCPv6PacketTypes.RELAY_REPL, chain[0].InnerPacket.PacketType); for (int i = 1; i < chain.Count; i++) { Assert.Equal(chain[i].InnerPacket, chain[i - 1]); } Assert.Equal(inputPacket, chain[depth]); }
private DHCPv6Packet GetSolicitPacket( Random random, out DUID clientDuid, out UInt32 iaId, params DHCPv6PacketOption[] options) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::1")); clientDuid = new UUIDDUID(random.NextGuid()); iaId = random.NextUInt32(); var packetOptions = new List <DHCPv6PacketOption>(options) { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid), new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.Zero, TimeSpan.Zero, Array.Empty <DHCPv6PacketSuboption>()), new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), }; DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(), DHCPv6PacketTypes.Solicit, packetOptions); return(packet); }
public void FromByteArray_AddressListOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); UInt16 firstIdentifier = random.NextUInt16(); UInt16 secondIdentifier = random.NextUInt16(); DHCPv6PacketOptionFactory.AddOptionType(firstIdentifier, (data) => DHCPv6PacketIPAddressListOption.FromByteArray(data, 0), false); DHCPv6PacketOptionFactory.AddOptionType(secondIdentifier, (data) => DHCPv6PacketIPAddressListOption.FromByteArray(data, 0), false); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIPAddressListOption(firstIdentifier, random.GetIPv6Addresses(2, 5)), new DHCPv6PacketIPAddressListOption(secondIdentifier, random.GetIPv6Addresses(2, 5)), } ); CheckByteRepresentation(packet, header); }
public static DHCPv6PacketIPAddressListOption FromByteArray(Byte[] data, Int32 offset) { if (data == null || data.Length < offset + 4) { throw new ArgumentException(nameof(data)); } UInt16 code = ByteHelper.ConvertToUInt16FromByte(data, offset); UInt16 length = ByteHelper.ConvertToUInt16FromByte(data, offset + 2); Int32 addressAmount = length / 16; var addresses = new IPv6Address[addressAmount]; for (int i = 0; i < addressAmount; i++) { IPv6Address address = IPv6Address.FromByteArray(data, offset + 4 + (i * 16)); addresses[i] = address; } return(new DHCPv6PacketIPAddressListOption(code, addresses)); }
public void HasUniqueIdentifier(Boolean shouldHave) { Random random = new Random(); IPv6Address address = random.GetIPv6Address(); String booleanValue = shouldHave == true ? "true" : "false"; Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); serializerMock.Setup(x => x.Deserialze <IPv6Address>(address.ToString())).Returns(address).Verifiable(); serializerMock.Setup(x => x.Deserialze <Boolean>(booleanValue)).Returns(shouldHave).Verifiable(); var resolver = new DHCPv6PeerAddressResolver(); resolver.ApplyValues(new Dictionary <String, String> { { "PeerAddress", address.ToString() }, { "IsUnique", booleanValue }, }, serializerMock.Object); Assert.Equal(shouldHave, resolver.HasUniqueIdentifier); }
public void WithOldAndNewBinding() { Random random = new Random(); Guid guid = random.NextGuid(); PrefixBinding oldPrefixBinding = new PrefixBinding( IPv6Address.FromString("fe80:1:2::0"), new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(62)), IPv6Address.FromString("fe80:FF:2::3")); PrefixBinding newPrefixBinding = new PrefixBinding( IPv6Address.FromString("fd80:1:4::0"), new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(64)), IPv6Address.FromString("fd80:FE:2::3")); var trigger = PrefixEdgeRouterBindingUpdatedTrigger.WithOldAndNewBinding(guid, oldPrefixBinding, newPrefixBinding); Assert.NotNull(trigger); Assert.Equal(guid, trigger.ScopeId); Assert.Equal(oldPrefixBinding, trigger.OldBinding); Assert.Equal(newPrefixBinding, trigger.NewBinding); }
public void GetAllDevices() { Random random = new Random(); var devices = new List <Device> { new Device { Id = random.NextGuid(), DUID = new UUIDDUID(random.NextGuid()), LinkLocalAddress = IPv6Address.FromString("fe80::8e21:d9ff:fecd:e2a"), MacAddress = new byte[] { 0x8C, 0x21, 0xD9, 0xCD, 0x0E, 0x2A }, Name = "My first test device", }, new Device { Id = random.NextGuid(), DUID = new UUIDDUID(random.NextGuid()), LinkLocalAddress = IPv6Address.FromString("fe80::449c:35ff:fec0:a1bc"), MacAddress = new byte[] { 0x46, 0x9C, 0x35, 0xC0, 0xA1, 0xBC }, Name = "a device", } }; Mock <IDHCPv6ReadStore> storeMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict); storeMock.Setup(x => x.GetAllDevices()).Returns(devices).Verifiable(); var controller = new DeviceController( storeMock.Object, Mock.Of <ILogger <DeviceController> >()); var actionResult = controller.GetAllDevices(); var result = actionResult.EnsureOkObjectResult <IEnumerable <DeviceOverviewResponse> >(true); Assert.Equal(devices.Select(x => new DeviceOverviewResponse { Name = x.Name, Id = x.Id }), result, new DeviceOverviewComparer()); storeMock.Verify(); }
public void HandleRelease_ScopeNotFound_ByAddress() { Random random = new Random(); var packet = GetReleasePacket(random, out _, out _, out _, true); var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { AddressProperties = new DHCPv6ScopeAddressProperties( IPv6Address.FromString("fe80::10"), IPv6Address.FromString("fe80::ff"), new List <IPv6Address> { IPv6Address.FromString("fe80::12") }, preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), reuseAddressIfPossible: false, addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), }); DHCPv6Packet result = rootScope.HandleRelease(packet, GetServerPropertiesResolver()); Assert.Equal(DHCPv6Packet.Empty, result); //CheckErrorPacket(leasedAddress, iaId, result, DHCPv6PrefixDelegation.None,DHCPv6StatusCodes.NoBinding); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, null, DHCPv6ReleaseHandledEvent.ReleaseError.ScopeNotFound); }
protected DHCPv6RootScope GetRootScope(Random random, out DHCPv6Packet packet) { packet = GetSolicitPacket(random, out _, out _); var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); var rootScope = new DHCPv6RootScope(Guid.NewGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new List <DomainEvent> { new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { AddressProperties = new DHCPv6ScopeAddressProperties( IPv6Address.FromString("fe80::0"), IPv6Address.FromString("fe80::ff"), new List <IPv6Address> { IPv6Address.FromString("fe80::1") }, t1: DHCPv6TimeScale.FromDouble(0.25), t2: DHCPv6TimeScale.FromDouble(0.75), preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), rapitCommitEnabled: true, addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next, prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues( IPv6Address.FromString("2a64:40::0"), new IPv6SubnetMaskIdentifier(64), new IPv6SubnetMaskIdentifier(64)) ), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }) }); return(rootScope); }
public static IPv6Address Parse(string address) { if (address == null) { throw new ArgumentNullException("Bad string address"); } TryAgain: int Size = 28; sockaddr_in6 SockAddrIN6 = new sockaddr_in6(); int ret = WSAStringToAddress(address, AddressFamily.InterNetworkV6, IntPtr.Zero, ref SockAddrIN6, ref Size); if (ret != 0) { int Err = Marshal.GetLastWin32Error(); if (Err == 10093) { WSAData wsaData = new WSAData(); ret = WSAStartup((short)0x0202, out wsaData); if (ret != 0) { throw new ArgumentException("WSAStartup failed"); } goto TryAgain; } throw new ArgumentException("WSAStringToAddress failed for " + address + " error " + Err.ToString()); } IPv6Address instance = new IPv6Address(SockAddrIN6.sin6_addr, SockAddrIN6.sin6_scope_id); return(instance); }
public void HandleRebind_ScopeFound_ButPseudoResolverUsed() { Random random = new Random(); var packet = GetRelayedRebindPacket(random, out IPv6Address _, out _, out _, true); var resolverInformations = GetMockupPseudoResolver(out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { AddressProperties = new DHCPv6ScopeAddressProperties( IPv6Address.FromString("fe80::01"), IPv6Address.FromString("fe80::ff"), new List <IPv6Address> { IPv6Address.FromString("fe80::02") }, preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), reuseAddressIfPossible: false, addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), }); DHCPv6Packet result = rootScope.HandleRebind(packet, GetServerPropertiesResolver()); Assert.Equal(DHCPv6Packet.Empty, result); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, null, DHCPv6RebindHandledEvent.RebindErrors.ScopeNotFound); }
public void GetIPv6LinkLocalAddressFromDevice_DeviceFound(Boolean devicesAddedLater) { Random random = new Random(); Guid id = random.NextGuid(); IPv6Address linkLocalAddress = IPv6Address.FromString("fe80::2314"); Device device = new Device { Id = id, LinkLocalAddress = linkLocalAddress }; var service = new InMemoryDeviceService(devicesAddedLater == true ? null : new[] { device }); if (devicesAddedLater == true) { service.AddDevices(new[] { device }); } var actual = service.GetIPv6LinkLocalAddressFromDevice(id); Assert.Equal(linkLocalAddress, actual); }
protected static DHCPv6ScopeAddressProperties GetScopeAddressProperties(IScopeChangeCommand request) => request.AddressProperties.DynamicRenewTime == null ? new DHCPv6ScopeAddressProperties ( IPv6Address.FromString(request.AddressProperties.Start), IPv6Address.FromString(request.AddressProperties.End), request.AddressProperties.ExcludedAddresses.Select(x => IPv6Address.FromString(x)), request.AddressProperties.T1 == null ? null : DHCPv6TimeScale.FromDouble(request.AddressProperties.T1.Value), request.AddressProperties.T2 == null ? null : DHCPv6TimeScale.FromDouble(request.AddressProperties.T2.Value), preferredLifeTime: request.AddressProperties.PreferredLifeTime, validLifeTime: request.AddressProperties.ValidLifeTime, reuseAddressIfPossible: request.AddressProperties.ReuseAddressIfPossible, addressAllocationStrategy: (Beer.DaAPI.Core.Scopes.ScopeAddressProperties <DHCPv6ScopeAddressProperties, IPv6Address> .AddressAllocationStrategies?)request.AddressProperties.AddressAllocationStrategy, supportDirectUnicast: request.AddressProperties.SupportDirectUnicast, acceptDecline: request.AddressProperties.AcceptDecline, informsAreAllowd: request.AddressProperties.InformsAreAllowd, rapitCommitEnabled: request.AddressProperties.RapitCommitEnabled, prefixDelgationInfo: request.AddressProperties.PrefixDelgationInfo == null ? null : DHCPv6PrefixDelgationInfo.FromValues( IPv6Address.FromString(request.AddressProperties.PrefixDelgationInfo.Prefix), new IPv6SubnetMaskIdentifier(request.AddressProperties.PrefixDelgationInfo.PrefixLength), new IPv6SubnetMaskIdentifier(request.AddressProperties.PrefixDelgationInfo.AssingedPrefixLength)) ) : new DHCPv6ScopeAddressProperties ( IPv6Address.FromString(request.AddressProperties.Start), IPv6Address.FromString(request.AddressProperties.End), request.AddressProperties.ExcludedAddresses.Select(x => IPv6Address.FromString(x)), GetDynamicRenewTime(request.AddressProperties.DynamicRenewTime), reuseAddressIfPossible: request.AddressProperties.ReuseAddressIfPossible, addressAllocationStrategy: (Beer.DaAPI.Core.Scopes.ScopeAddressProperties <DHCPv6ScopeAddressProperties, IPv6Address> .AddressAllocationStrategies?)request.AddressProperties.AddressAllocationStrategy, supportDirectUnicast: request.AddressProperties.SupportDirectUnicast, acceptDecline: request.AddressProperties.AcceptDecline, informsAreAllowd: request.AddressProperties.InformsAreAllowd, rapitCommitEnabled: request.AddressProperties.RapitCommitEnabled, prefixDelgationInfo: request.AddressProperties.PrefixDelgationInfo == null ? null : DHCPv6PrefixDelgationInfo.FromValues( IPv6Address.FromString(request.AddressProperties.PrefixDelgationInfo.Prefix), new IPv6SubnetMaskIdentifier(request.AddressProperties.PrefixDelgationInfo.PrefixLength), new IPv6SubnetMaskIdentifier(request.AddressProperties.PrefixDelgationInfo.AssingedPrefixLength)));
public void FromByteArray_RelayPacket_MultipleRelayPacket() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.ReconfigureAccepte), }); DHCPv6RelayPacket innerRelayPacket = DHCPv6RelayPacket.AsInnerRelay( true, random.NextByte(), IPv6Address.FromString("fe80::acde"), IPv6Address.FromString("fe80::acdf"), new List <DHCPv6PacketOption> { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(40)), new DHCPv6PacketRemoteIdentifierOption(random.NextUInt32(), random.NextBytes(50)) }, innerPacket); DHCPv6RelayPacket relayPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, random.NextByte(), IPv6Address.FromString("fe80::acde"), IPv6Address.FromString("fe80::acdf"), new List <DHCPv6PacketOption> { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(23)), new DHCPv6PacketRemoteIdentifierOption(random.NextUInt32(), random.NextBytes(15)) }, innerRelayPacket); CheckByteRepresentation(relayPacket, header); }
public async Task Handle() { Random random = new Random(); String interfaceName = random.GetAlphanumericString(); var possibleListeners = GetPossibleListeners(); var selectedListener = possibleListeners.ElementAt(1); var command = new CreateDHCPv6InterfaceListenerCommand( selectedListener.PhysicalInterfaceId, selectedListener.Address.ToString(), interfaceName); Mock <IDHCPv6InterfaceEngine> interfaceEngineMock = new Mock <IDHCPv6InterfaceEngine>(MockBehavior.Strict); interfaceEngineMock.Setup(x => x.GetPossibleListeners()).Returns(possibleListeners).Verifiable(); interfaceEngineMock.Setup(x => x.GetActiveListeners()).ReturnsAsync(possibleListeners.Take(1)).Verifiable(); interfaceEngineMock.Setup(x => x.OpenListener(It.Is <DHCPv6Listener>(y => y.Address == IPv6Address.FromString(command.IPv6Addres)))).Returns(true).Verifiable(); Mock <IDHCPv6StorageEngine> storageEngineMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict); storageEngineMock.Setup(x => x.Save(It.Is <DHCPv6Listener>(y => y.Name == interfaceName && y.PhysicalInterfaceId == command.NicId && y.Address == IPv6Address.FromString(command.IPv6Addres) ))).ReturnsAsync(true).Verifiable(); var commandHandler = new CreateDHCPv6InterfaceListenerCommandHandler( interfaceEngineMock.Object, storageEngineMock.Object, Mock.Of <ILogger <CreateDHCPv6InterfaceListenerCommandHandler> >()); Guid?result = await commandHandler.Handle(command, CancellationToken.None); Assert.True(result.HasValue); Assert.NotEqual(Guid.Empty, result.Value); interfaceEngineMock.Verify(); storageEngineMock.Verify(); }
public async Task Handle_NoResponseAvaiable() { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, 1, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption>()); DHCPv6Packet reseponsePacket = DHCPv6Packet.Empty; Mock <IDHCPv6LeaseEngine> leaseEngineMock = new Mock <IDHCPv6LeaseEngine>(MockBehavior.Strict); leaseEngineMock.Setup(x => x.HandlePacket(packet)).ReturnsAsync(reseponsePacket).Verifiable(); Mock <IServiceBus> serviceBusMock = new Mock <IServiceBus>(MockBehavior.Strict); ValidDHCPv6PacketArrivedMessageHandler handler = new ValidDHCPv6PacketArrivedMessageHandler( Mock.Of <IServiceBus>(MockBehavior.Strict), leaseEngineMock.Object, Mock.Of <ILogger <ValidDHCPv6PacketArrivedMessageHandler> >()); await handler.Handle(new ValidDHCPv6PacketArrivedMessage(packet), CancellationToken.None); leaseEngineMock.Verify(); serviceBusMock.Verify(); }
private void ReadInitialValues() { LowpanIdentity = new LowpanIdentity(wpanApi); LowpanCredential = new LowpanCredential(wpanApi); ncpVersion = wpanApi.DoNCPVersion(); protocolVersion = wpanApi.DoProtocolVersion(); interfaceType = (InterfaceType)wpanApi.DoInterfaceType(); vendor = wpanApi.DoVendor(); capabilities = wpanApi.DoCaps(); supportedChannels = wpanApi.DoChannels(); scanMask = wpanApi.DoChannelsMask(); networkInterfaceState = wpanApi.DoInterfaceConfig(); threadStackState = wpanApi.DoThread(); state = (State)wpanApi.DoState(); extendedAddress = new HardwareAddress(wpanApi.DoExtendedAddress().bytes); hardwareAddress = new HardwareAddress(wpanApi.DoPhysicalAddress().bytes); ipAddresses = NetUtilities.SpinelIPtoSystemIP(wpanApi.DoIPAddresses()); ipLinkLocal = new IPv6Address(wpanApi.DoIPLinkLocal64().bytes); ipMeshLocal = new IPv6Address(wpanApi.DoIPMeshLocal64().bytes); }
public async Task Handle(Boolean storageResult) { Random random = new Random(); String filtername = random.GetAlphanumericString(); IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, IPv6Address.FromString("fe80::3"), IPv6Address.FromString("fe80::4"), Array.Empty <DHCPv6PacketOption>(), DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.ADVERTISE, new List <DHCPv6PacketOption>())); Mock <IDHCPv6StorageEngine> storageEngineMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict); storageEngineMock.Setup(x => x.LogFilteredDHCPv6Packet(packet, filtername)).ReturnsAsync(storageResult); DHCPv6PacketFileteredMessageHandler handler = new DHCPv6PacketFileteredMessageHandler( storageEngineMock.Object, Mock.Of <ILogger <DHCPv6PacketFileteredMessageHandler> >()); await handler.Handle(new DHCPv6PacketFilteredMessage(packet, filtername), CancellationToken.None); storageEngineMock.Verify(); }
public void Create() { Random random = new Random(); String interfaceId = random.NextGuid().ToString(); IPv6Address address = random.GetIPv6Address(); String interfaceName = random.GetAlphanumericString(); DHCPv6Listener listener = DHCPv6Listener.Create(interfaceId, DHCPListenerName.FromString(interfaceName), address); Assert.NotNull(listener); Assert.NotEqual(Guid.Empty, listener.Id); Assert.Equal(address, listener.Address); Assert.Equal(interfaceName, listener.Name); Assert.Equal(interfaceId, listener.PhysicalInterfaceId); var @event = GetFirstEvent <DHCPListenerCreatedEvent>(listener); Assert.Equal(address.ToString(), @event.Address); Assert.Equal(listener.Id, @event.Id); Assert.Equal(interfaceId, @event.InterfaceId); Assert.Equal(interfaceName, @event.Name); }
private void GenerateScopeTree( Double randomValue, Random random, List <Guid> parents, ICollection <DomainEvent> events ) { if (randomValue > 0) { return; } Int32 scopeAmount = random.Next(3, 10); Guid directParentId = parents.Last(); for (int i = 0; i < scopeAmount; i++) { Guid scopeId = Guid.NewGuid(); IPv6Address start = random.GetIPv6Address(); IPv6Address end = start + 100; events.Add(new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction { Id = scopeId, Name = random.GetAlphanumericString(), AddressProperties = new DHCPv6ScopeAddressProperties(start, end), ParentId = directParentId, })); List <Guid> newParentList = new List <Guid>(parents) { scopeId }; GenerateScopeTree( randomValue + random.NextDouble(), random, newParentList, events); } }
public void PacketMeetsCondition(Boolean shouldMeetCondition) { Random random = new Random(); Guid deviceId = random.NextGuid(); LinkLayerAddressDUID duid = new LinkLayerAddressDUID( LinkLayerAddressDUID.DUIDLinkLayerTypes.Ethernet, new Byte[] { 0x5c, 0xa6, 0x2d, 0xd9, 0x88, 0x00 }); Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); serializerMock.Setup(x => x.Deserialze <Guid>(deviceId.ToString())).Returns(deviceId).Verifiable(); Mock <IDeviceService> deviceServiceMock = new Mock <IDeviceService>(MockBehavior.Strict); deviceServiceMock.Setup(x => x.GetDuidFromDevice(deviceId)).Returns(duid).Verifiable(); var resolver = new DeviceBasedDHCPv6ClientDUIDResolver(deviceServiceMock.Object); resolver.ApplyValues(new Dictionary <String, String> { { "DeviceId", deviceId.ToString() }, }, serializerMock.Object); var packet = DHCPv6RelayPacket.AsOuterRelay(new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")), true, 1, random.GetIPv6Address(), random.GetIPv6Address(), Array.Empty <DHCPv6PacketOption>(), DHCPv6RelayPacket.AsInnerRelay( true, 0, IPv6Address.FromString("2004::1"), IPv6Address.FromString("fe80::1"), new DHCPv6PacketOption[] { }, DHCPv6Packet.AsInner(random.NextUInt16(), DHCPv6PacketTypes.Solicit, new[] { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, shouldMeetCondition == true ? (DUID)duid : new UUIDDUID(random.NextGuid())) }))); Boolean result = resolver.PacketMeetsCondition(packet); Assert.Equal(shouldMeetCondition, result); serializerMock.Verify(); deviceServiceMock.Verify(); }
public void PacketMeetsCondition(Boolean shouldMeetCondition) { Random random = new Random(); Guid deviceId = random.NextGuid(); String ipAddress = "fe80::1"; IPv6Address address = IPv6Address.FromString(ipAddress); Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); serializerMock.Setup(x => x.Deserialze <Guid>(deviceId.ToString())).Returns(deviceId).Verifiable(); Mock <IDeviceService> deviceServiceMock = new Mock <IDeviceService>(MockBehavior.Strict); deviceServiceMock.Setup(x => x.GetIPv6LinkLocalAddressFromDevice(deviceId)).Returns(address).Verifiable(); var resolver = new DeviceBasedDHCPv6PeerAddressResolver(deviceServiceMock.Object); resolver.ApplyValues(new Dictionary <String, String> { { "DeviceId", deviceId.ToString() }, }, serializerMock.Object); var packet = DHCPv6RelayPacket.AsOuterRelay(new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")), true, 1, random.GetIPv6Address(), random.GetIPv6Address(), Array.Empty <DHCPv6PacketOption>(), DHCPv6RelayPacket.AsInnerRelay( true, 0, IPv6Address.FromString("fe80::1"), shouldMeetCondition == true ? IPv6Address.FromString(ipAddress) : IPv6Address.FromString("2004::1"), new DHCPv6PacketOption[] { }, DHCPv6Packet.AsInner(random.NextUInt16(), DHCPv6PacketTypes.Solicit, Array.Empty <DHCPv6PacketOption>()))); Boolean result = resolver.PacketMeetsCondition(packet); Assert.Equal(shouldMeetCondition, result); serializerMock.Verify(); }
public async Task ShouldPacketBeFilterd_SameAdressBelowLimit() { DHCPv6RateLimitBasedFilter filter = new DHCPv6RateLimitBasedFilter( Mock.Of <ILogger <DHCPv6RateLimitBasedFilter> >()); UInt16 packetsPerSeconds = (UInt16)_rand.Next(30, 100); filter.PacketsPerSecons = packetsPerSeconds; TimeSpan timePerPacket = TimeSpan.FromSeconds(packetsPerSeconds / 1000.0); Int32 packetAmount = _rand.Next(packetsPerSeconds * 2, packetsPerSeconds * 4); IPv6Address serverAddress = IPv6Address.FromByteArray(_rand.NextBytes(16)); IPv6Address address = IPv6Address.FromByteArray(_rand.NextBytes(16)); for (int i = 0; i < packetAmount; i++) { DateTime start = DateTime.Now; IPv6HeaderInformation header = new IPv6HeaderInformation(address, serverAddress); DHCPv6Packet packet = new DHCPv6Packet(header, 1, DHCPv6PacketTypes.Solicit, Array.Empty <DHCPv6PacketOption>()); Boolean result = await filter.ShouldPacketBeFiltered(packet); Assert.False(result); DateTime end = DateTime.Now; TimeSpan diff = end - start; TimeSpan timeToWait = timePerPacket - diff; if (timeToWait.TotalMilliseconds > 0) { await Task.Delay(timeToWait); } } }
public void TestConfigAAAARecord() { var config = ParseXML(@" <zone> <SOA name=""example.com"" class=""IN"" ttl=""7200"" primary-ns=""ns.example.com"" hostmaster=""admin.example.com"" serial=""0"" refresh=""3600"" retry=""60"" expire=""3600"" min-ttl=""60"" /> <AAAA name=""www.example.com"" class=""IN"" ttl=""3600"" address=""2001:0DB8:AC10:FE01:0000:0000:0000:0000"" /> </zone> " ); var zone = DNSZone.Unserialize(config); var records = new List <DNSRecord>(); records.Add(new DNSRecord( new Domain("www.example.com"), AddressClass.INTERNET, 3600, new AAAAResource(IPv6Address.Parse("2001:0DB8:AC10:FE01:0000:0000:0000:0000")))); Assert.That(zone.Records, Is.EquivalentTo(records)); }
public void PacketMeetsCondition_False_NotRelay() { Random random = new Random(); String value = random.GetAlphanumericString(); IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); var packetOptions = new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), }; DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(), DHCPv6PacketTypes.Solicit, packetOptions); Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); serializerMock.Setup(x => x.Deserialze <String>(value)).Returns(value).Verifiable(); serializerMock.Setup(x => x.Deserialze <UInt16>("0")).Returns(0).Verifiable(); serializerMock.Setup(x => x.Deserialze <Boolean>("true")).Returns(true).Verifiable(); var resolver = new DHCPv6MilegateResolver(); resolver.ApplyValues(new Dictionary <String, String> { { "Value", value }, { "Index", "0" }, { "IsCaseSenstiveMatch", "true" }, }, serializerMock.Object); Boolean result = resolver.PacketMeetsCondition(packet); Assert.False(result); serializerMock.Verify(); }
private static void UDPListenerThread(IPv6Address ipAddress, ushort port) { UdpSocket receiver = new UdpSocket(); receiver.Bind(ipAddress, port); IPv6EndPoint remoteIp = null; isUdpListenerRunning = true; while (isUdpListenerRunning) { if (receiver.Poll(-1, SelectMode.SelectRead)) { byte[] data = receiver.Receive(ref remoteIp); string message = Encoding.ASCII.GetString(data); Console.WriteLine("\n"); Console.WriteLine("{0} bytes from {1} {2} {3}", message.Length, remoteIp.Address, remoteIp.Port, message); Console.WriteLine(">"); } } receiver.Close(); receiver = null; }
public void PacketMeetsCondition_False_NotRelay() { Random random = new Random(); Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict); DHCPv6SimpleZyxelIESResolver resolver = new DHCPv6SimpleZyxelIESResolver(); IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); var packetOptions = new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), }; DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(), DHCPv6PacketTypes.Solicit, packetOptions); Boolean result = resolver.PacketMeetsCondition(packet); Assert.False(result); serializerMock.Verify(); }
/// <summary> /// Overrides System.Object.ToString to return /// this object rendered in a quad-dotted notation /// </summary> public override string ToString () { if(m_Family == AddressFamily.InterNetwork) return ToString (m_Address); else { ushort[] numbers = m_Numbers.Clone() as ushort[]; for(int i=0; i<numbers.Length; i++) numbers[i] = (ushort)NetworkToHostOrder((short)numbers[i]); IPv6Address v6 = new IPv6Address(numbers); v6.ScopeId = ScopeId; return v6.ToString(); } }
public static bool IsLoopback (IPv6Address addr) { if (addr.address [7] != 1) return false; int x = addr.address [6] >> 8; if (x != 0x7f && x != 0) return false; for (int i = 0; i < 4; i++) { if (addr.address [i] != 0) return false; } if (addr.address [5] != 0 && addr.address [5] != 0xffff) return false; return true; }
public static bool TryParse (string ipString, out IPv6Address result) { result = null; if (ipString == null) return false; if (ipString.Length > 2 && ipString [0] == '[' && ipString [ipString.Length - 1] == ']') ipString = ipString.Substring (1, ipString.Length - 2); if (ipString.Length < 2) return false; int prefixLen = 0; int scopeId = 0; int pos = ipString.LastIndexOf ('/'); if (pos != -1) { string prefix = ipString.Substring (pos + 1); if (!TryParse (prefix , out prefixLen)) prefixLen = -1; if (prefixLen < 0 || prefixLen > 128) return false; ipString = ipString.Substring (0, pos); } else { pos = ipString.LastIndexOf ('%'); if (pos != -1) { string prefix = ipString.Substring (pos + 1); if (!TryParse (prefix, out scopeId)) scopeId = 0; ipString = ipString.Substring (0, pos); } } // // At this point the prefix/suffixes have been removed // and we only have to deal with the ipv4 or ipv6 addressed // ushort [] addr = new ushort [8]; // // Is there an ipv4 address at the end? // bool ipv4 = false; int pos2 = ipString.LastIndexOf (':'); if (pos2 == -1) return false; int slots = 0; if (pos2 < (ipString.Length - 1)) { string ipv4Str = ipString.Substring (pos2 + 1); if (ipv4Str.IndexOf ('.') != -1) { IPAddress ip; if (!IPAddress.TryParse (ipv4Str, out ip)) return false; long a = ip.InternalIPv4Address; addr [6] = (ushort) (((int) (a & 0xff) << 8) + ((int) ((a >> 8) & 0xff))); addr [7] = (ushort) (((int) ((a >> 16) & 0xff) << 8) + ((int) ((a >> 24) & 0xff))); if (pos2 > 0 && ipString [pos2 - 1] == ':') ipString = ipString.Substring (0, pos2 + 1); else ipString = ipString.Substring (0, pos2); ipv4 = true; slots = 2; } } // // Only an ipv6 block remains, either: // "hexnumbers::hexnumbers", "hexnumbers::" or "hexnumbers" // int c = ipString.IndexOf ("::"); if (c != -1){ int right_slots = Fill (addr, ipString.Substring (c+2)); if (right_slots == -1){ return false; } if (right_slots + slots > 8){ return false; } int d = 8-slots-right_slots; for (int i = right_slots; i > 0; i--){ addr [i+d-1] = addr [i-1]; addr [i-1] = 0; } int left_slots = Fill (addr, ipString.Substring (0, c)); if (left_slots == -1) return false; if (left_slots + right_slots + slots > 7) return false; } else { if (Fill (addr, ipString) != 8-slots) return false; } // Now check the results in the ipv6-address range only bool ipv6 = false; for (int i = 0; i < slots; i++){ if (addr [i] != 0 || i == 5 && addr [i] != 0xffff) ipv6 = true; } // check IPv4 validity if (ipv4 && !ipv6) { for (int i = 0; i < 5; i++) { if (addr [i] != 0) return false; } if (addr [5] != 0 && addr [5] != 0xffff) return false; } result = new IPv6Address (addr, prefixLen, scopeId); return true; }