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;
}
