util/src/main/java/org/opendaylight/protocol/util/Ipv4Util.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.util;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.net.InetAddresses;
  12 import com.google.common.primitives.UnsignedBytes;
  13 import io.netty.buffer.ByteBuf;
  14 import io.netty.buffer.Unpooled;
  15 import java.net.InetAddress;
  16 import java.net.InetSocketAddress;
  17 import java.util.ArrayList;
  18 import java.util.Arrays;
  19 import java.util.Collections;
  20 import java.util.List;
  21 import java.util.Map;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  27
  28 /**
  29  * Util class for creating generated Ipv4Address.
  30  */
  31 public final class Ipv4Util {
  32     public static final int IP4_LENGTH = 4;
  33     public static final int IP4_BITS_LENGTH = 32;
  34     private static final Ipv4Prefix EMPTY_PREFIX = new Ipv4Prefix("0.0.0.0/0");
  35
  36     private Ipv4Util() {
  37         throw new UnsupportedOperationException();
  38     }
  39
  40     /**
  41      * Reads from ByteBuf buffer and converts bytes to Ipv4Address.
  42      *
  43      * @param buffer containing Ipv4 address, starting at reader index
  44      * @return Ipv4Address
  45      */
  46     public static Ipv4Address addressForByteBuf(final ByteBuf buffer) {
  47         return IetfInetUtil.INSTANCE.ipv4AddressFor(ByteArray.readBytes(buffer, IP4_LENGTH));
  48     }
  49
  50     /**
  51      * From string ipAddress creates an InetAddress and puts it into ByteBuf.
  52      *
  53      * @param ipAddress Ipv4 address
  54      * @return ByteBuf with filled in bytes from ipAddress
  55      */
  56     public static ByteBuf byteBufForAddress(final Ipv4Address ipAddress) {
  57         return Unpooled.wrappedBuffer(bytesForAddress(ipAddress));
  58     }
  59
  60     /**
  61      * Converts Ipv4Address to byte array.
  62      *
  63      * @param address Ipv4Address to be converted
  64      * @return byte array
  65      */
  66     public static byte[] bytesForAddress(final Ipv4Address address) {
  67         return IetfInetUtil.INSTANCE.ipv4AddressBytes(address);
  68     }
  69
  70     public static int prefixBitsToBytes(final int bits) {
  71         if (bits % Byte.SIZE != 0) {
  72             return (bits / Byte.SIZE) + 1;
  73         }
  74         return bits / Byte.SIZE;
  75     }
  76
  77     /**
  78      * Returns number of minimum bytes needed to cover all bits of prefix.
  79      */
  80     public static int getPrefixLengthBytes(final String prefix) {
  81         return prefixBitsToBytes(Ipv4Util.getPrefixLength(prefix));
  82     }
  83
  84     /**
  85      * Converts Ipv4Prefix to byte array. Prefix length at the end.
  86      *
  87      * @param prefix Ipv4Prefix to be converted
  88      * @return byte array with prefix length at the end
  89      */
  90     public static byte[] bytesForPrefix(final Ipv4Prefix prefix) {
  91         return IetfInetUtil.INSTANCE.ipv4PrefixToBytes(prefix);
  92     }
  93
  94     /**
  95      * Creates an Ipv4Prefix object from given byte array.
  96      *
  97      * @param bytes  IPv4 address
  98      * @param length prefix length
  99      * @return Ipv4Prefix object
 100      */
 101     public static Ipv4Prefix prefixForBytes(final byte[] bytes, final int length) {
 102         Preconditions.checkArgument(length <= bytes.length * Byte.SIZE);
 103
 104         final byte[] tmp;
 105         if (bytes.length != IP4_LENGTH) {
 106             tmp = Arrays.copyOfRange(bytes, 0, IP4_LENGTH);
 107         } else {
 108             tmp = bytes;
 109         }
 110
 111         return IetfInetUtil.INSTANCE.ipv4PrefixFor(tmp, length);
 112     }
 113
 114     /**
 115      * Creates an Ipv4Prefix object from given ByteBuf. Prefix length is assumed to
 116      * be in the left most byte of the buffer.
 117      *
 118      * @param buf Buffer containing serialized prefix
 119      * @return Ipv4Prefix object
 120      */
 121     public static Ipv4Prefix prefixForByteBuf(final ByteBuf buf) {
 122         final int prefixLength = UnsignedBytes.toInt(buf.readByte());
 123         final int size = prefixLength / Byte.SIZE + ((prefixLength % Byte.SIZE == 0) ? 0 : 1);
 124         final int readable = buf.readableBytes();
 125         Preconditions.checkArgument(size <= readable, "Illegal length of IP prefix: %s/%s", size, readable);
 126
 127         final byte[] bytes = new byte[IP4_LENGTH];
 128         buf.readBytes(bytes, 0, size);
 129         return IetfInetUtil.INSTANCE.ipv4PrefixFor(bytes, prefixLength);
 130     }
 131
 132     /**
 133      * Creates a list of Ipv4 Prefixes from given byte array.
 134      *
 135      * @param bytes to be converted to List of Ipv4Prefixes.
 136      * @return A list of Ipv4Prefixes
 137      */
 138     public static List<Ipv4Prefix> prefixListForBytes(final byte[] bytes) {
 139         if (bytes.length == 0) {
 140             return Collections.emptyList();
 141         }
 142         final List<Ipv4Prefix> list = new ArrayList<>();
 143         int byteOffset = 0;
 144         while (byteOffset < bytes.length) {
 145             final int bitLength = UnsignedBytes.toInt(bytes[byteOffset]);
 146             byteOffset += 1;
 147             // if length == 0, default route will be added
 148             if (bitLength == 0) {
 149                 list.add(EMPTY_PREFIX);
 150                 continue;
 151             }
 152
 153             list.add(IetfInetUtil.INSTANCE.ipv4PrefixForShort(bytes, byteOffset, bitLength));
 154             byteOffset += bitLength / Byte.SIZE;
 155             if (bitLength % Byte.SIZE != 0) {
 156                 byteOffset++;
 157             }
 158
 159         }
 160         return list;
 161     }
 162
 163     /**
 164      * Obtains prefix length from given string prefix.
 165      *
 166      * @param prefixValue value of prefix
 167      * @return prefix length
 168      */
 169     protected static int getPrefixLength(final String prefixValue) {
 170         final int sep = prefixValue.indexOf('/');
 171         return Integer.parseInt(prefixValue.substring(sep + 1, prefixValue.length()));
 172     }
 173
 174     /**
 175      * Converts InetAddress to IpAddress.
 176      *
 177      * @param inetAddress address
 178      * @return IpAddress
 179      */
 180     public static IpAddress getIpAddress(final InetAddress inetAddress) {
 181         return IetfInetUtil.INSTANCE.ipAddressFor(inetAddress);
 182     }
 183
 184     /**
 185      * Converts IpAddress and PortNumber to InetSocketAddress.
 186      *
 187      * @param ipAddress address
 188      * @param port      number
 189      * @return InetSocketAddress
 190      */
 191     public static InetSocketAddress toInetSocketAddress(final IpAddress ipAddress, final PortNumber port) {
 192         final String ipString = toStringIP(ipAddress);
 193         return new InetSocketAddress(InetAddresses.forString(ipString), port.getValue());
 194     }
 195
 196     /**
 197      * Increment Address.
 198      *
 199      * @param ipv4Address String containing Ipv4Address
 200      * @return String containing Ipv4Address incremented by 1
 201      */
 202     public static String incrementIpv4Address(final String ipv4Address) {
 203         return InetAddresses.increment(InetAddresses.forString(ipv4Address)).getHostAddress();
 204     }
 205
 206     /**
 207      * Increment Address.
 208      *
 209      * @param ipv4Address ipv4 address to be incremented
 210      * @return new ipv4 address
 211      */
 212     public static Ipv4Address incrementIpv4Address(final Ipv4Address ipv4Address) {
 213         return new Ipv4Address(incrementIpv4Address(ipv4Address.getValue()));
 214     }
 215
 216     public static Ipv4Prefix incrementIpv4Prefix(final Ipv4Prefix ipv4Prefix) {
 217         final Map.Entry<Ipv4Address, Integer> splitIpv4Prefix = IetfInetUtil.INSTANCE.splitIpv4Prefix(ipv4Prefix);
 218         return IetfInetUtil.INSTANCE.ipv4PrefixFor(incrementIpv4Address(splitIpv4Prefix.getKey()),
 219                 splitIpv4Prefix.getValue());
 220     }
 221
 222     /**
 223      * Get string representation of IpAddress.
 224      *
 225      * @param ipAddress address
 226      * @return String value of Ipv4Address or Ipv6Address
 227      */
 228     public static String toStringIP(final IpAddress ipAddress) {
 229         if (ipAddress.getIpv4Address() != null) {
 230             return ipAddress.getIpv4Address().getValue();
 231         }
 232         return ipAddress.getIpv6Address().getValue();
 233     }
 234 }