public DHCPv6Packet(IPv6HeaderInformation header, UInt32 transactionId, DHCPv6PacketTypes packetType, IEnumerable <DHCPv6PacketOption> options)
{
Header = header;
TransactionId = transactionId;
PacketType = packetType;
_options = new List <DHCPv6PacketOption>(options);
}
public async Task GetErrorCodesPerDHCPV6RequestType()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
var response = new Dictionary <Int32, Int32>();
DateTime start = DateTime.UtcNow.AddHours(-random.Next(5, 10));
DateTime end = DateTime.UtcNow.AddHours(-random.Next(1, 2));
DHCPv6PacketTypes packetType = random.GetEnumValue <DHCPv6PacketTypes>();
Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict);
readStoreMock.Setup(x => x.GetErrorCodesPerDHCPV6RequestType(start, end, packetType)).ReturnsAsync(response).Verifiable();
var controller = new DHCPv6StatisticsController(rootScope, readStoreMock.Object);
var actionResult = await controller.GetErrorCodesPerDHCPV6RequestType(new DHCPv6PacketTypeBasedTimeSeriesFilterRequest
{
Start = start,
End = end,
PacketType = packetType,
});
var result = actionResult.EnsureOkObjectResult <IDictionary <Int32, Int32> >(true);
Assert.NotNull(result);
Assert.Equal(response, result);
readStoreMock.Verify();
}
private void CheckPacket(DHCPv6Packet packet, DHCPv6PacketTypes expectedType)
{
if (packet == null || packet.IsValid == false || packet.GetInnerPacket().PacketType != expectedType)
{
_logger.LogError("unexpected packet type found");
throw new ScopeException(DHCPv4ScopeExceptionReasons.InvalidPacket);
}
}
internal DHCPv6RelayPacket(
DHCPv6PacketTypes type,
Byte hopCount,
IPv6Address linkAddress, IPv6Address peerAddress,
IEnumerable <DHCPv6PacketOption> options,
DHCPv6Packet innerPacket) : base(type, options)
{
HopCount = hopCount;
LinkAddress = linkAddress;
PeerAddress = peerAddress;
InnerPacket = innerPacket;
}
private DHCPv6PacketHandledEntry(DHCPv6PacketHandledEvent handledEvent, DHCPv6PacketTypes type) : this()
{
Timestamp = handledEvent.Timestamp;
RequestType = type;
Request = new DHCPv6PacketInformation(handledEvent.Request);
ResultCode = handledEvent.ErrorCode;
ScopeId = handledEvent.ScopeId;
if (handledEvent.Response != null)
{
ResponseType = handledEvent.Response.GetInnerPacket().PacketType;
Response = new DHCPv6PacketInformation(handledEvent.Response);
}
}
internal static DHCPv6RelayPacket FromByteArray(byte[] rawData, int offset)
{
DHCPv6PacketTypes type = (DHCPv6PacketTypes)rawData[offset];
offset += 1;
Byte hopCount = rawData[offset];
offset += 1;
IPv6Address linkAddress = IPv6Address.FromByteArray(rawData, offset);
offset += 16;
IPv6Address peerAddress = IPv6Address.FromByteArray(rawData, offset);
offset += 16;
List <DHCPv6PacketOption> options = new List <DHCPv6PacketOption>();
Byte[] innerPacketOptionValue = null;
Int32 byteIndex = offset;
while (byteIndex < rawData.Length)
{
UInt16 optionCode = ByteHelper.ConvertToUInt16FromByte(rawData, byteIndex);
UInt16 length = ByteHelper.ConvertToUInt16FromByte(rawData, byteIndex + 2);
Byte[] optionData = ByteHelper.CopyData(rawData, byteIndex, length + 4);
if (optionCode == (Byte)DHCPv6PacketOptionTypes.RelayMessage)
{
innerPacketOptionValue = ByteHelper.CopyData(optionData, 4);
}
else
{
DHCPv6PacketOption suboption = DHCPv6PacketOptionFactory.GetOption(optionCode, optionData);
options.Add(suboption);
}
byteIndex += 4 + length;
}
return(new DHCPv6RelayPacket(
type,
hopCount,
linkAddress, peerAddress,
options,
DHCPv6Packet.FromByteArray(innerPacketOptionValue)));
}
protected static DHCPv6Packet FromByteArray(Byte[] rawData)
{
DHCPv6PacketTypes type = (DHCPv6PacketTypes)rawData[0];
DHCPv6Packet result;
if (type == DHCPv6PacketTypes.RELAY_REPL || type == DHCPv6PacketTypes.RELAY_FORW)
{
result = DHCPv6RelayPacket.FromByteArray(rawData, 0);
}
else
{
UInt32 transactionId = (UInt32)((rawData[1] << 16) | (rawData[2] << 8) | rawData[3]);
result = new DHCPv6Packet(
type, transactionId,
DHCPv6PacketOptionFactory.GetOptions(rawData, 4));
}
return(result);
}
protected static void CheckPrefixPacket(
DHCPv6Packet result, DHCPv6PacketTypes type, DHCPv6PrefixDelegation prefixDelegation)
{
Assert.NotNull(result);
Assert.NotEqual(DHCPv6Packet.Empty, result);
Assert.True(result.IsValid);
Assert.Equal(type, result.PacketType);
var iaOption = result.GetPrefixDelegationIdentiyAssocation(prefixDelegation.IdentityAssociation);
Assert.NotNull(iaOption);
var uncastedSuboption = iaOption.Suboptions.First();
Assert.NotNull(uncastedSuboption);
Assert.IsAssignableFrom <DHCPv6PacketIdentityAssociationPrefixDelegationSuboption>(uncastedSuboption);
var addressSubOption = (DHCPv6PacketIdentityAssociationPrefixDelegationSuboption)uncastedSuboption;
Assert.Equal(prefixDelegation.Mask.Identifier, addressSubOption.PrefixLength);
Assert.Equal(prefixDelegation.NetworkAddress, addressSubOption.Address);
Assert.NotEmpty(addressSubOption.Suboptions);
Assert.Single(addressSubOption.Suboptions);
var uncastedSubSuboption = addressSubOption.Suboptions.First();
Assert.NotNull(uncastedSubSuboption);
Assert.IsAssignableFrom <DHCPv6PacketStatusCodeSuboption>(uncastedSubSuboption);
var statusSubOption = (DHCPv6PacketStatusCodeSuboption)uncastedSubSuboption;
Assert.Equal((UInt16)DHCPv6StatusCodes.Success, statusSubOption.StatusCode);
Assert.False(String.IsNullOrEmpty(statusSubOption.Message));
}
public DHCPv6PacketReconfigureOption(DHCPv6PacketTypes type) : base(DHCPv6PacketOptionTypes.Reconfigure, (Byte)type)
{
MessageType = type;
}
private DHCPv6Packet(DHCPv6PacketTypes type, UInt32 transactionId, IEnumerable <DHCPv6PacketOption> options)
{
PacketType = type;
TransactionId = transactionId;
_options = new List <DHCPv6PacketOption>(options);
}
protected DHCPv6Packet(DHCPv6PacketTypes type, IEnumerable <DHCPv6PacketOption> options)
{
PacketType = type;
_options = new List <DHCPv6PacketOption>(options ?? Array.Empty <DHCPv6PacketOption>());
}
public static DHCPv6Packet AsInner(UInt32 transactionId, DHCPv6PacketTypes packetType, IEnumerable <DHCPv6PacketOption> options) => new DHCPv6Packet(null, transactionId, packetType, options);
public static DHCPv6Packet AsOuter(IPv6HeaderInformation header, UInt32 transactionId, DHCPv6PacketTypes packetType, IEnumerable <DHCPv6PacketOption> options) => new DHCPv6Packet(header, transactionId, packetType, options);
protected static void CheckPacket(DHCPv6Packet request,
IPv6Address expectedAdress, UInt32 iaId, DHCPv6Packet response, DHCPv6PacketTypes type, DHCPv6PrefixDelegation prefixDelegation)
{
Assert.NotNull(response);
Assert.NotEqual(DHCPv6Packet.Empty, response);
Assert.True(response.IsValid);
Assert.Equal(type, response.GetInnerPacket().PacketType);
CheckIfPacketIsCorrectReply(request, response);
if (iaId != 0)
{
var iaOption = response.GetInnerPacket().GetNonTemporaryIdentiyAssocation(iaId);
Assert.NotNull(iaOption);
var uncastedSuboption = iaOption.Suboptions.First();
Assert.NotNull(uncastedSuboption);
Assert.IsAssignableFrom <DHCPv6PacketIdentityAssociationAddressSuboption>(uncastedSuboption);
var addressSubOption = (DHCPv6PacketIdentityAssociationAddressSuboption)uncastedSuboption;
Assert.Equal(expectedAdress, addressSubOption.Address);
Assert.NotEmpty(addressSubOption.Suboptions);
Assert.Single(addressSubOption.Suboptions);
var uncastedSubSuboption = addressSubOption.Suboptions.First();
Assert.NotNull(uncastedSubSuboption);
Assert.IsAssignableFrom <DHCPv6PacketStatusCodeSuboption>(uncastedSubSuboption);
var statusSubOption = (DHCPv6PacketStatusCodeSuboption)uncastedSubSuboption;
Assert.Equal((UInt16)DHCPv6StatusCodes.Success, statusSubOption.StatusCode);
Assert.False(String.IsNullOrEmpty(statusSubOption.Message));
}
if (prefixDelegation != DHCPv6PrefixDelegation.None)
{
var iaOption = response.GetInnerPacket().GetPrefixDelegationIdentiyAssocation(prefixDelegation.IdentityAssociation);
Assert.NotNull(iaOption);
Assert.Equal(prefixDelegation.IdentityAssociation, iaOption.Id);
Assert.NotEmpty(iaOption.Suboptions);
Assert.Single(iaOption.Suboptions);
var uncastedSuboption = iaOption.Suboptions.First();
Assert.NotNull(uncastedSuboption);
Assert.IsAssignableFrom <DHCPv6PacketIdentityAssociationPrefixDelegationSuboption>(uncastedSuboption);
var addressSubOption = (DHCPv6PacketIdentityAssociationPrefixDelegationSuboption)uncastedSuboption;
Assert.Equal(prefixDelegation.Mask.Identifier, addressSubOption.PrefixLength);
Assert.NotEmpty(addressSubOption.Suboptions);
Assert.Single(addressSubOption.Suboptions);
var uncastedSubSuboption = addressSubOption.Suboptions.First();
Assert.NotNull(uncastedSubSuboption);
Assert.IsAssignableFrom <DHCPv6PacketStatusCodeSuboption>(uncastedSubSuboption);
var statusSubOption = (DHCPv6PacketStatusCodeSuboption)uncastedSubSuboption;
Assert.Equal((UInt16)DHCPv6StatusCodes.Success, statusSubOption.StatusCode);
Assert.False(String.IsNullOrEmpty(statusSubOption.Message));
}
}
public async Task <IDictionary <Int32, Int32> > GetErrorCodesPerDHCPV6RequestType(DateTime?start, DateTime?end, DHCPv6PacketTypes packetType) =>
await GetSimpleStatisticsData <Int32, Int32>(AppendTimeRangeToUrl($"/api/Statistics/ErrorCodesPerDHCPV6RequestType?PacketType={packetType}", start, end));
