final LispMapResolverDetails mapResolverDetails =
dumpOptional.get().lispMapResolverDetails.stream()
.filter(a -> addressesEqual(key.getIpAddress(),
- arrayToIpAddressReversed(byteToBoolean(a.isIpv6), a.ipAddress)))
+ arrayToIpAddress(byteToBoolean(a.isIpv6), a.ipAddress)))
.collect(RWUtils.singleItemCollector());
builder.setKey(key);
return dumpOptional.get().lispMapResolverDetails.stream()
.map(resolver -> new MapResolverKey(
- arrayToIpAddressReversed(byteToBoolean(resolver.isIpv6), resolver.ipAddress)))
+ arrayToIpAddress(byteToBoolean(resolver.isIpv6), resolver.ipAddress)))
.collect(Collectors.toList());
}
}
private Locator detailsToLocator(final LispLocatorDetails details) {
- final IpAddress address = arrayToIpAddressReversed(byteToBoolean(details.isIpv6), details.ipAddress);
+ final IpAddress address = arrayToIpAddress(byteToBoolean(details.isIpv6), details.ipAddress);
return new LocatorBuilder()
.setAddress(address)
.setKey(new LocatorKey(address))
switch (type) {
case IPV4: {
return newLocalEidBuilder(Ipv4Afi.class, vni).setAddress(
- new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZoneReversed(address)).build())
+ new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZone(address)).build())
.build();
}
case IPV6: {
return newLocalEidBuilder(Ipv6Afi.class, vni).setAddress(
- new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZoneReversed(address)).build())
+ new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZone(address)).build())
.build();
}
case MAC: {
case IPV4: {
return newRemoteEidBuilder(Ipv4Afi.class, vni)
.setAddress(
- new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZoneReversed(address))
+ new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZone(address))
.build())
.build();
}
case IPV6: {
return newRemoteEidBuilder(Ipv6Afi.class, vni)
.setAddress(
- new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZoneReversed(address))
+ new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZone(address))
.build())
.build();
}
case IPV4: {
return newEidBuilderLocal(Ipv4Afi.class, vni)
.setAddress(
- new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZoneReversed(address))
+ new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZone(address))
.build())
.build();
}
case IPV6: {
return newEidBuilderLocal(Ipv6Afi.class, vni)
.setAddress(
- new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZoneReversed(address))
+ new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZone(address))
.build())
.build();
}
case IPV4: {
return newEidBuilderRemote(Ipv4Afi.class, vni)
.setAddress(
- new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZoneReversed(address))
+ new Ipv4Builder().setIpv4(arrayToIpv4AddressNoZone(address))
.build())
.build();
}
case IPV6: {
return newEidBuilderRemote(Ipv6Afi.class, vni)
.setAddress(
- new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZoneReversed(address))
+ new Ipv6Builder().setIpv6(arrayToIpv6AddressNoZone(address))
.build())
.build();
}
EidType type, byte[] address) {
switch (type) {
case IPV4: {
- return arrayToIpv4AddressNoZoneReversed(address).getValue();
+ return arrayToIpv4AddressNoZone(address).getValue();
}
case IPV6: {
- return arrayToIpv6AddressNoZoneReversed(address).getValue();
+ return arrayToIpv6AddressNoZone(address).getValue();
}
case MAC: {
//as wrong as it looks ,its right(second param is not end index,but count)
assertNotNull(request);
assertEquals("Locator", new String(request.locatorSetName));
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.eid).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue());
assertEquals(0, request.eidType);
assertEquals(1, request.isAdd);
assertEquals(25, request.vni);
assertNotNull(request);
assertEquals("Locator", new String(request.locatorSetName));
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.eid).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue());
assertEquals(0, request.eidType);
assertEquals(0, request.isAdd);
assertEquals(25, request.vni);
LispAddDelMapResolver request = resolverCaptor.getValue();
assertEquals(1, request.isAdd);
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.ipAddress).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.ipAddress).getValue());
}
LispAddDelMapResolver request = resolverCaptor.getValue();
assertEquals(0, request.isAdd);
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.ipAddress).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.ipAddress).getValue());
}
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
- customizer
- .writeCurrentAttributes(null, mock(RemoteMapping.class), writeContext);
+ customizer.writeCurrentAttributes(null, mock(RemoteMapping.class), writeContext);
}
@Test
assertNotNull(request);
assertEquals(1, request.isAdd);
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.eid).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue());
assertEquals(25, request.vni);
}
assertNotNull(request);
assertEquals(0, request.isAdd);
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(request.eid).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue());
assertEquals(25, request.vni);
}
package io.fd.hc2vpp.nat.read;
+import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.util.RWUtils;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.vpp.jvpp.snat.dto.SnatAddressDetails;
import io.fd.vpp.jvpp.snat.dto.SnatAddressDetailsReplyDump;
import io.fd.vpp.jvpp.snat.dto.SnatAddressDump;
dumpMgr.getDump(id, ctx.getModificationCache(), null)
.or(new SnatAddressDetailsReplyDump()).snatAddressDetails.get(Math.toIntExact(poolId));
- builder.setExternalIpPool(
- new Ipv4Prefix(arrayToIpv4AddressNoZoneReversed(details.ipAddress).getValue() + "/32"));
+ builder.setExternalIpPool(new Ipv4Prefix(arrayToIpv4AddressNoZone(details.ipAddress).getValue() + "/32"));
builder.setPoolId(poolId);
LOG.trace("External IP pool: {}. Read as: {}", id, builder);
package io.fd.hc2vpp.nat.read;
+import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.nat.util.MappingEntryContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.util.RWUtils;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDump;
builder.setType(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.MappingEntry.Type.Static);
// Snat only supports ipv4 for now
- builder.setExternalSrcAddress(arrayToIpv4AddressNoZoneReversed(snatStaticMappingDetails.externalIpAddress));
+ builder.setExternalSrcAddress(arrayToIpv4AddressNoZone(snatStaticMappingDetails.externalIpAddress));
builder.setInternalSrcAddress(
- new IpAddress(arrayToIpv4AddressNoZoneReversed(snatStaticMappingDetails.localIpAddress)));
+ new IpAddress(arrayToIpv4AddressNoZone(snatStaticMappingDetails.localIpAddress)));
if (snatStaticMappingDetails.addrOnly == 0) {
builder.setExternalSrcPort(new ExternalSrcPortBuilder()
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
+import io.fd.honeycomb.translate.MappingContext;
import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
import java.util.Collections;
import java.util.Comparator;
private MappingEntryKey entryToKey(final SnatStaticMappingDetails entry) {
// Only IPv4
return new MappingEntryKey(
- new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZoneReversed(entry.externalIpAddress))),
- new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZoneReversed(entry.localIpAddress))));
+ new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(entry.externalIpAddress))),
+ new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(entry.localIpAddress))));
}
private boolean equalEntries(final SnatStaticMappingDetails detail, final MappingEntry ctxMappingEntry) {
final IpAddress internalAddrFromDetails =
- new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZoneReversed(detail.localIpAddress)));
+ new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(detail.localIpAddress)));
// Only IPv4
if (!ctxMappingEntry.getInternal().equals(internalAddrFromDetails)) {
return false;
}
// Only IPv4
final IpAddress externalAddrFromDetails =
- new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZoneReversed(detail.externalIpAddress)));
+ new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(detail.externalIpAddress)));
if (!ctxMappingEntry.getExternal().equals(externalAddrFromDetails)) {
return false;
}
.build();
}
- private static Subnet getSubnet(final Address address) {
- final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.Subnet
- subnet = address.getSubnet();
-
- // Only prefix length supported
- Preconditions.checkArgument(
- subnet instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength);
-
- return new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder()
- .setPrefixLength(
- ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength) subnet)
- .getPrefixLength()).build();
- }
-
- static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address> getCfgId(
- final InstanceIdentifier<Address> id) {
- return InterfaceCustomizer.getCfgId(RWUtils.cutId(id, Interface.class))
- .augmentation(Interface1.class)
- .child(Ipv4.class)
- .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address.class,
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressKey(
- id.firstKeyOf(Address.class).getIp()));
- }
-
@Override
@Nonnull
public AddressBuilder getBuilder(@Nonnull InstanceIdentifier<Address> id) {
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
- builder.setIp(arrayToIpv4AddressNoZoneReversed(detail.ip))
- .setSubnet(
- new PrefixLengthBuilder().setPrefixLength(Short.valueOf(detail.prefixLength)).build());
+ builder.setIp(arrayToIpv4AddressNoZone(detail.ip))
+ .setSubnet(new PrefixLengthBuilder().setPrefixLength(Short.valueOf(detail.prefixLength)).build());
if (LOG.isDebugEnabled()) {
LOG.debug("Attributes for {} interface (id={}) address {} successfully read: {}",
.setSubnet(getSubnet(readValue))
.build());
}
+
+ private static Subnet getSubnet(final Address address) {
+ final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.Subnet
+ subnet = address.getSubnet();
+
+ // Only prefix length supported
+ Preconditions.checkArgument(
+ subnet instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength);
+
+ return new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder()
+ .setPrefixLength(
+ ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength) subnet)
+ .getPrefixLength()).build();
+ }
+
+ static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address> getCfgId(
+ final InstanceIdentifier<Address> id) {
+ return InterfaceCustomizer.getCfgId(RWUtils.cutId(id, Interface.class))
+ .augmentation(Interface1.class)
+ .child(Ipv4.class)
+ .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address.class,
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressKey(id.firstKeyOf(Address.class).getIp()));
+ }
}
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.AddressDumpParams;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.AddressDumpParams;
+import io.fd.honeycomb.translate.util.RWUtils;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.dto.IpAddressDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
import java.util.Collections;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yangtools.yang.binding.Identifier;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
/**
* Utility class providing Ipv4 read support.
@Nonnull final Function<Ipv4AddressNoZone, T> keyConstructor) {
if (dumpOptional.isPresent() && dumpOptional.get().ipAddressDetails != null) {
return dumpOptional.get().ipAddressDetails.stream()
- .map(detail -> keyConstructor.apply(arrayToIpv4AddressNoZoneReversed(detail.ip)))
+ .map(detail -> keyConstructor.apply(arrayToIpv4AddressNoZone(detail.ip)))
.collect(Collectors.toList());
} else {
return Collections.emptyList();
final List<IpAddressDetails> details = dump.get().ipAddressDetails;
return Optional.of(details.stream()
- .filter(singleDetail -> ip.equals(arrayToIpv4AddressNoZoneReversed(singleDetail.ip)))
+ .filter(singleDetail -> ip.equals(arrayToIpv4AddressNoZone(singleDetail.ip)))
.collect(RWUtils.singleItemCollector()));
}
return Optional.absent();
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
- builder.setIp(arrayToIpv4AddressNoZoneReversed(detail.ip));
+ builder.setIp(arrayToIpv4AddressNoZone(detail.ip));
builder.setSubnet(new PrefixLengthBuilder().setPrefixLength(Short.valueOf(detail.prefixLength)).build());
if (LOG.isDebugEnabled()) {
return new IpAddress(arrayToIpv4AddressNoZone(ip));
}
}
-
- /**
- * Converts array bytes to {@link IpAddress}
- */
- @Nonnull
- default IpAddress arrayToIpAddressReversed(boolean isIpv6, byte[] ip) {
- if (isIpv6) {
- return new IpAddress(arrayToIpv6AddressNoZoneReversed(ip));
- } else {
- return new IpAddress(arrayToIpv4AddressNoZoneReversed(ip));
- }
- }
-
- default IpAddress reverseAddress(@Nonnull final IpAddress address) {
- //arrayToIpAdddress internaly reverts order
- return arrayToIpAddress(isIpv6(address), ipAddressToArray(address));
- }
}
}
return new Ipv4AddressRange(
- Ipv4Translator.INSTANCE.arrayToIpv4AddressNoZoneReversed(prefixAddrBytes0),
- Ipv4Translator.INSTANCE.arrayToIpv4AddressNoZoneReversed(prefixAddrBytesF));
+ Ipv4Translator.INSTANCE.arrayToIpv4AddressNoZone(prefixAddrBytes0),
+ Ipv4Translator.INSTANCE.arrayToIpv4AddressNoZone(prefixAddrBytesF));
}
}
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.net.InetAddresses;
+import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import javax.annotation.Nonnull;
/**
* Make available also from static context.
*/
- Ipv4Translator INSTANCE = new Ipv4Translator() {};
+ Ipv4Translator INSTANCE = new Ipv4Translator() {
+ };
/**
* Creates address array from address part of {@link Ipv4Prefix}
}
/**
- * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order.
+ * Parse byte array returned by VPP representing an Ipv4 address. Expects array in big endian
*
* @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No
* change in order.
ip = Arrays.copyOfRange(ip, 0, 4);
}
try {
- // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order
- // compared to byte order it was submitted
- return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip)));
+ return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddress.getByAddress(ip)));
} catch (UnknownHostException e) {
throw new IllegalArgumentException("Unable to parse ipv4", e);
}
}
- /**
- * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order.
- *
- * @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No
- * change in order.
- */
- @Nonnull
- default Ipv4AddressNoZone arrayToIpv4AddressNoZoneReversed(@Nonnull byte[] ip) {
- // VPP sends ipv4 in a 16 byte array
-
- if (ip.length == 16) {
- ip = Arrays.copyOfRange(ip, 0, 4);
- }
-
- ip = reverseBytes(ip);
-
- try {
- // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order
- // compared to byte order it was submitted
- return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip)));
- } catch (UnknownHostException e) {
- throw new IllegalArgumentException("Unable to parse ipv4", e);
- }
- }
-
-
/**
* Transform Ipv4 address to a byte array acceptable by VPP. VPP expects incoming byte array to be in the same order
* as the address.
import static com.google.common.base.Preconditions.checkState;
import com.google.common.net.InetAddresses;
+import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.List;
/**
* Creates address array from address part of {@link Ipv6Prefix}
*/
- default byte[] ipv6AddressPrefixToArray(@Nonnull final Ipv6Prefix ipv4Prefix) {
- checkNotNull(ipv4Prefix, "Cannot convert null prefix");
+ default byte[] ipv6AddressPrefixToArray(@Nonnull final Ipv6Prefix ipv6Prefix) {
+ checkNotNull(ipv6Prefix, "Cannot convert null prefix");
return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone(
- new Ipv6Address(ipv4Prefix.getValue().substring(0, ipv4Prefix.getValue().indexOf('/')))));
+ new Ipv6Address(ipv6Prefix.getValue().substring(0, ipv6Prefix.getValue().indexOf('/')))));
}
/**
}
/**
- * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in reversed order.
+ * Parse byte array returned by VPP representing an Ipv6 address. Expects array in non-reversed order
*
- * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No
+ * @return Ipv6ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No
* change in order.
*/
@Nonnull
checkArgument(ip.length == 16, "Illegal array length");
try {
- return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip)));
+ return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddress.getByAddress(ip)));
} catch (UnknownHostException e) {
throw new IllegalArgumentException("Unable to parse ipv6", e);
}
return address.getIpv6Address() != null;
}
- /**
- * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in natural order.
- *
- * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No
- * change in order.
- */
- @Nonnull
- default Ipv6AddressNoZone arrayToIpv6AddressNoZoneReversed(@Nonnull byte[] ip) {
- checkArgument(ip.length == 16, "Illegal array length");
-
- ip = reverseBytes(ip);
-
- try {
- return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip)));
- } catch (UnknownHostException e) {
- throw new IllegalArgumentException("Unable to parse ipv6", e);
- }
- }
-
-
/**
* Detects whether {@code IpPrefix} is ipv6
*/
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.hc2vpp.common.translate.util;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
-
-public class AddressTranslatorTest implements AddressTranslator {
-
- @Test
- public void testRevertAddress() {
- assertEquals("1.2.168.192",
- reverseAddress(new IpAddress(new Ipv4Address("192.168.2.1"))).getIpv4Address().getValue());
- assertEquals("3473:7003:2e8a::a385:b80d:120",
- reverseAddress(new IpAddress(new Ipv6Address("2001:db8:85a3:0:0:8a2e:370:7334"))).getIpv6Address()
- .getValue());
- }
-}
\ No newline at end of file
import static org.junit.Assert.assertEquals;
-import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1");
byte[] bytes = ipv4AddressNoZoneToArray(ipv4Addr);
assertEquals((byte) 192, bytes[0]);
- // Simulating the magic of VPP
- bytes = reverseBytes(bytes);
final Ipv4AddressNoZone ipv4AddressNoZone = arrayToIpv4AddressNoZone(bytes);
assertEquals(ipv4Addr, ipv4AddressNoZone);
}
public void testIpv4AddressPrefixToArray() {
byte[] ip = ipv4AddressPrefixToArray(new Ipv4Prefix("192.168.2.1/24"));
- assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(ip).getValue());
+ assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(ip).getValue());
}
@Test
import static org.junit.Assert.assertEquals;
-import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
final Ipv6AddressNoZone ipv6Addr = new Ipv6AddressNoZone("3ffe:1900:4545:3:200:f8ff:fe21:67cf");
byte[] bytes = ipv6AddressNoZoneToArray(ipv6Addr);
assertEquals((byte) 63, bytes[0]);
-
- bytes = reverseBytes(bytes);
final Ipv6AddressNoZone ivp6AddressNoZone = arrayToIpv6AddressNoZone(bytes);
assertEquals(ipv6Addr, ivp6AddressNoZone);
}
public void testIpv6AddressPrefixToArray() {
byte[] ip = ipv6AddressPrefixToArray(new Ipv6Prefix("3ffe:1900:4545:3:200:f8ff:fe21:67cf/48"));
- assertEquals("cf67:21fe:fff8:2:300:4545:19:fe3f", arrayToIpv6AddressNoZone(ip).getValue());
+ assertEquals("3ffe:1900:4545:3:200:f8ff:fe21:67cf", arrayToIpv6AddressNoZone(ip).getValue());
}
@Test
public void testIpv4AddressPrefixToArray() {
byte[] ip = ipv6AddressPrefixToArray(new Ipv6Prefix("2001:0db8:0a0b:12f0:0000:0000:0000:0001/128"));
- assertEquals("100::f012:b0a:b80d:120", arrayToIpv6AddressNoZone(ip).getValue());
+ assertEquals("2001:db8:a0b:12f0::1", arrayToIpv6AddressNoZone(ip).getValue());
}
@Test