public async Task ShowAddInterfaceDialog(DHCPv4InterfaceEntry entry)
{
var parameters = new DialogParameters
{
{ nameof(CreateDHCPv4InterfaceDialog.Entry), entry }
};
var messageForm = _dialogService.Show <CreateDHCPv4InterfaceDialog>(String.Format(L["CreateInterfaceDialogHeader"], entry.InterfaceName), parameters);
var result = await messageForm.Result;
if (result.IsSuccess() == true)
{
_snackBarService.Add(String.Format(L["CreateInterfaceSuccessSnackbarContent"], entry.IPv4Address), Severity.Success);
_interfaceOverview = await _service.GetDHCPv4Interfaces();
}
}
public async Task SendAndReceive()
{
Random random = new Random();
String dbName = $"{random.Next()}";
String eventStorePrefix = random.GetAlphanumericString();
var serviceInteractions = GetTestClient(dbName, eventStorePrefix);
Byte[] opt82Value = random.NextBytes(10);
try
{
//Get and Add Interface
var interfacesResult = await serviceInteractions.GetAsync("/api/interfaces/dhcpv4/");
var interfaces = await IsObjectResult <DHCPv4InterfaceOverview>(interfacesResult);
DHCPv4InterfaceEntry usedInterface = null;
foreach (var item in interfaces.Entries)
{
try
{
var createInterfaceResult = await serviceInteractions.PostAsync("/api/interfaces/dhcpv4/", GetContent(new
{
name = "my test interface",
ipv4Address = item.IPv4Address,
interfaceId = item.PhysicalInterfaceId
}));
Guid interfaceDaAPIId = await IsObjectResult <Guid>(createInterfaceResult);
Assert.NotEqual(Guid.Empty, interfaceDaAPIId);
usedInterface = item;
break;
}
catch (Exception)
{
continue;
}
}
Assert.NotNull(usedInterface);
var interfaceAddress = IPv4Address.FromString(usedInterface.IPv4Address);
//Create scope
var createScopeResult = await serviceInteractions.PostAsync("/api/scopes/dhcpv4/", GetContent(new
{
name = "Testscope",
id = Guid.NewGuid(),
addressProperties = new
{
start = "192.168.10.1",
end = "192.168.10.254",
excludedAddresses = new[] { "192.168.10.1" },
preferredLifetime = TimeSpan.FromDays(0.8),
leaseTime = TimeSpan.FromDays(1),
renewalTime = TimeSpan.FromDays(0.5),
maskLength = 24,
supportDirectUnicast = true,
acceptDecline = true,
informsAreAllowd = true,
reuseAddressIfPossible = true,
addressAllocationStrategy = Beer.DaAPI.Shared.Requests.DHCPv4ScopeRequests.V1.DHCPv4ScopeAddressPropertyReqest.AddressAllocationStrategies.Next
},
resolver = new
{
typename = nameof(DHCPv4Option82Resolver),
propertiesAndValues = new Dictionary <String, String>
{
{ nameof(DHCPv4Option82Resolver.Value), System.Text.Json.JsonSerializer.Serialize(opt82Value) },
}
}
}));
Guid scopeId = await IsObjectResult <Guid>(createScopeResult);
Assert.NotEqual(Guid.Empty, scopeId);
IPAddress address = new IPAddress(interfaceAddress.GetBytes());
IPEndPoint ownEndPoint = new IPEndPoint(address, 68);
IPEndPoint serverEndPoint = new IPEndPoint(address, 67);
UdpClient client = new UdpClient(ownEndPoint);
IPv4HeaderInformation headerInformation =
new IPv4HeaderInformation(IPv4Address.FromString(address.ToString()), IPv4Address.Broadcast);
DHCPv4Packet discoverPacket = new DHCPv4Packet(
headerInformation, random.NextBytes(6), (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty, DHCPv4PacketFlags.Broadcast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Discover),
new DHCPv4PacketRawByteOption(82, opt82Value),
new DHCPv4PacketClientIdentifierOption(DHCPv4ClientIdentifier.FromIdentifierValue("my custom client")));
byte[] discoverPacketStream = discoverPacket.GetAsStream();
await client.SendAsync(discoverPacketStream, discoverPacketStream.Length, serverEndPoint);
await Task.Delay(2000);
var content = await client.ReceiveAsync();
Byte[] receivedBytes = content.Buffer;
DHCPv4Packet response = DHCPv4Packet.FromByteArray(receivedBytes, new IPv4HeaderInformation(interfaceAddress, interfaceAddress));
Assert.NotNull(response);
Assert.True(response.IsValid);
var serverIdentifierOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.ServerIdentifier) as DHCPv4PacketAddressOption;
Assert.NotNull(serverIdentifierOption);
Assert.Equal(interfaceAddress, serverIdentifierOption.Address);
var subnetOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.SubnetMask) as DHCPv4PacketAddressOption;
Assert.NotNull(subnetOption);
Assert.Equal(IPv4Address.FromString("255.255.255.0"), subnetOption.Address);
var clientIdentifierOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.ClientIdentifier) as DHCPv4PacketClientIdentifierOption;
Assert.NotNull(clientIdentifierOption);
Assert.Equal("my custom client", clientIdentifierOption.Identifier.IdentifierValue);
Assert.Equal(DUID.Empty, clientIdentifierOption.Identifier.DUID);
Assert.Equal((UInt32)0, clientIdentifierOption.Identifier.IaId);
Assert.Empty(clientIdentifierOption.Identifier.HwAddress);
var incoming82Option = response.GetOptionByIdentifier(DHCPv4OptionTypes.Option82) as DHCPv4PacketRawByteOption;
Assert.NotNull(incoming82Option);
Assert.Equal(opt82Value, incoming82Option.OptionData);
}
finally
{
await EventStoreClientDisposer.CleanUp(eventStorePrefix, null);
await DatabaseTestingUtility.DeleteDatabase(dbName);
}
}
