How to use

getCidrNetmask

method

in

com.cloud.utils.net.NetUtils

public static String getCidrNetmask(final String cidr) {
  final String[] cidrPair = cidr.split("\\/");
  final long guestCidrSize = Long.parseLong(cidrPair[1]);
  return getCidrNetmask(guestCidrSize);
}

public static String cidr2Netmask(final String cidr) {
  final String[] tokens = cidr.split("\\/");
  return getCidrNetmask(Integer.parseInt(tokens[1]));
}

assert size < MAX_CIDR : "You do know this is not for ipv6 right?  Keep it smaller than 32 but you have " + size;
final long startNetMask = ip2Long(getCidrNetmask(size));
final long startIp = (cidr & startNetMask) + 1; //exclude the first ip since it isnt valid, e.g., 192.168.10.0
int range = 1 << MAX_CIDR - size; //e.g., /24 = 2^8 = 256

public static Set<Long> getAllIpsFromCidr(final String cidr, final long size, final Set<Long> usedIps) {
  assert size < MAX_CIDR : "You do know this is not for ipv6 right?  Keep it smaller than 32 but you have " + size;
  final Set<Long> result = new TreeSet<Long>();
  final long ip = ip2Long(cidr);
  final long startNetMask = ip2Long(getCidrNetmask(size));
  long start = (ip & startNetMask) + 1;
  long end = start;
  end = end >> MAX_CIDR - size;
  end++;
  end = (end << MAX_CIDR - size) - 2;
  int maxIps = 255; // get 255 ips as maximum
  while (start <= end && maxIps > 0) {
    if (!usedIps.contains(start)) {
      result.add(start);
      maxIps--;
    }
    start++;
  }
  return result;
}

public static String getIpRangeStartIpFromCidr(final String cidr, final long size) {
  final long ip = ip2Long(cidr);
  final long startNetMask = ip2Long(getCidrNetmask(size));
  final long start = (ip & startNetMask) + 1;
  return long2Ip(start);
}

public static String getIpRangeEndIpFromCidr(final String cidr, final long size) {
  final long ip = ip2Long(cidr);
  final long startNetMask = ip2Long(getCidrNetmask(size));
  final long start = (ip & startNetMask) + 1;
  long end = start;
  end = end >> MAX_CIDR - size;
  end++;
  end = (end << MAX_CIDR - size) - 2;
  return long2Ip(end);
}

public static String[] getLocalCidrs() {
  final String defaultHostIp = getDefaultHostIp();
  final List<String> cidrList = new ArrayList<String>();
  try {
    for (final NetworkInterface ifc : IteratorUtil.enumerationAsIterable(NetworkInterface.getNetworkInterfaces())) {
      if (ifc.isUp() && !ifc.isVirtual() && !ifc.isLoopback()) {
        for (final InterfaceAddress address : ifc.getInterfaceAddresses()) {
          final InetAddress addr = address.getAddress();
          final int prefixLength = address.getNetworkPrefixLength();
          if (prefixLength < MAX_CIDR && prefixLength > 0) {
            final String ip = addr.getHostAddress();
            if (ip.equalsIgnoreCase(defaultHostIp)) {
              cidrList.add(ipAndNetMaskToCidr(ip, getCidrNetmask(prefixLength)));
            }
          }
        }
      }
    }
  } catch (final SocketException e) {
    s_logger.warn("UnknownHostException in getLocalCidrs().", e);
  }
  return cidrList.toArray(new String[0]);
}

public static Boolean IsIpEqualToNetworkOrBroadCastIp(final String requestedIp, final String cidr, final long size) {
  assert size < MAX_CIDR : "You do know this is not for ipv6 right?  Keep it smaller than 32 but you have " + size;
  final long ip = ip2Long(cidr);
  final long startNetMask = ip2Long(getCidrNetmask(size));
  final long start = ip & startNetMask;
  long end = start;
  end = end >> MAX_CIDR - size;
  end++;
  end = (end << MAX_CIDR - size) - 1;
  final long reqIp = ip2Long(requestedIp);
  if (reqIp == start || reqIp == end) {
    return true;
  }
  return false;
}
public static boolean isNetworkorBroadcastIP(String ip, String netmask){

public static String[] getIpRangeFromCidr(final String cidr, final long size) {
  assert size < MAX_CIDR : "You do know this is not for ipv6 right?  Keep it smaller than 32 but you have " + size;
  final String[] result = new String[2];
  final long ip = ip2Long(cidr);
  final long startNetMask = ip2Long(getCidrNetmask(size));
  final long start = (ip & startNetMask) + 1;
  long end = start;
  end = end >> MAX_CIDR - size;
  end++;
  end = (end << MAX_CIDR - size) - 2;
  result[0] = long2Ip(start);
  result[1] = long2Ip(end);
  return result;
}

private List<Pair<String, String>> getIpAddressRanges(Network network) {
  List<Pair<String, String>> ipAddressRanges = Lists.newArrayList();
  String subnet = NetUtils.getCidrSubNet(network.getCidr());
  String netmask = NetUtils.getCidrNetmask(network.getCidr());
  long cidrSize = NetUtils.getCidrSize(netmask);
  Set<Long> allIPsInCidr = NetUtils.getAllIpsFromCidr(subnet, cidrSize, new HashSet<Long>());
  if (allIPsInCidr == null || !(allIPsInCidr instanceof TreeSet)) {
    throw new IllegalStateException("The IPs in CIDR for subnet " + subnet + " where null or returned in a non-ordered set.");
  }
  Iterator<Long> ipIterator = allIPsInCidr.iterator();
  long ip =  ipIterator.next();
  long gatewayIp = NetUtils.ip2Long(network.getGateway());
  String lastIp = NetUtils.getIpRangeEndIpFromCidr(subnet, cidrSize);
  if (gatewayIp == ip) {
    ip = ipIterator.next();
    ipAddressRanges.add(Pair.of(NetUtils.long2Ip(ip), lastIp));
  } else if (!network.getGateway().equals(lastIp)) {
    ipAddressRanges.add(Pair.of(NetUtils.long2Ip(ip), NetUtils.long2Ip(gatewayIp - 1)));
    ipAddressRanges.add(Pair.of(NetUtils.long2Ip(gatewayIp + 1), lastIp));
  } else {
    ipAddressRanges.add(Pair.of(NetUtils.long2Ip(ip), NetUtils.long2Ip(gatewayIp - 1)));
  }
  return ipAddressRanges;
}

guestNic.setMode(guestNetwork.getMode());
final String gatewayCidr = guestNetwork.getCidr();
guestNic.setIPv4Netmask(NetUtils.getCidrNetmask(gatewayCidr));
guestNic.setDefaultNic(true);
networks.put(guestNetwork, new ArrayList<NicProfile>(Arrays.asList(guestNic)));

@Test
public void testGetCidrNetMask() {
  final String cidr = "10.10.0.0/16";
  String netmask = NetUtils.getCidrNetmask("10.10.10.10/16");
  assertTrue(cidr + " does not generate valid netmask " + netmask,NetUtils.isValidIp4Netmask(netmask));
}

final Network network = privateGW.retrievePrivateNetwork(this);
final String netmask = NetUtils.getCidrNetmask(network.getCidr());
final PrivateIpAddress ip = new PrivateIpAddress(ipVO, network.getBroadcastUri().toString(), network.getGateway(), netmask, nicProfile.getMacAddress());

final PrivateIpVO ipVO = _privateIpDao.findByIpAndSourceNetworkId(privateNic.getNetworkId(), privateNic.getIPv4Address());
final Network network = _networkDao.findById(privateNic.getNetworkId());
final String netmask = NetUtils.getCidrNetmask(network.getCidr());
final PrivateIpAddress ip = new PrivateIpAddress(ipVO, network.getBroadcastUri().toString(), network.getGateway(), netmask, privateNic.getMacAddress());

vlanNetmask = NetUtils.getCidrNetmask(network.getCidr());
sameSubnet = hasSameSubnet(ipv4, vlanGateway, vlanNetmask, newVlanGateway, newVlanNetmask, startIP, endIP,
    ipv6, ip6Gateway, ip6Cidr, startIPv6, endIPv6, network);

nic.setIPv4Netmask(NetUtils.getCidrNetmask(network.getCidr()));

@Override
public NicProfile createGuestNicProfileForVpcRouter(final RouterDeploymentDefinition vpcRouterDeploymentDefinition, final Network guestNetwork) {
  final NicProfile guestNic = new NicProfile();
  if (vpcRouterDeploymentDefinition.isRedundant()) {
    guestNic.setIPv4Address(_ipAddrMgr.acquireGuestIpAddress(guestNetwork, null));
  } else {
    guestNic.setIPv4Address(guestNetwork.getGateway());
  }
  guestNic.setBroadcastUri(guestNetwork.getBroadcastUri());
  guestNic.setBroadcastType(guestNetwork.getBroadcastDomainType());
  guestNic.setIsolationUri(guestNetwork.getBroadcastUri());
  guestNic.setMode(guestNetwork.getMode());
  final String gatewayCidr = _networkModel.getValidNetworkCidr(guestNetwork);
  guestNic.setIPv4Netmask(NetUtils.getCidrNetmask(gatewayCidr));
  return guestNic;
}

protected void getIp(NicProfile nic, DataCenter dc, Network network) throws InsufficientVirtualNetworkCapacityException, InsufficientAddressCapacityException {
  if (nic.getIPv4Address() == null) {
    PrivateIpVO ipVO = _privateIpDao.allocateIpAddress(network.getDataCenterId(), network.getId(), null);
    String vlanTag = BroadcastDomainType.getValue(network.getBroadcastUri());
    String netmask = NetUtils.getCidrNetmask(network.getCidr());
    PrivateIpAddress ip =
      new PrivateIpAddress(ipVO, vlanTag, network.getGateway(), netmask, NetUtils.long2Mac(NetUtils.createSequenceBasedMacAddress(ipVO.getMacAddress(), NetworkModel.MACIdentifier.value())));
    nic.setIPv4Address(ip.getIpAddress());
    nic.setIPv4Gateway(ip.getGateway());
    nic.setIPv4Netmask(ip.getNetmask());
    nic.setIsolationUri(IsolationType.Vlan.toUri(ip.getBroadcastUri()));
    nic.setBroadcastUri(IsolationType.Vlan.toUri(ip.getBroadcastUri()));
    nic.setBroadcastType(BroadcastDomainType.Vlan);
    nic.setFormat(AddressFormat.Ip4);
    nic.setReservationId(String.valueOf(ip.getBroadcastUri()));
    nic.setMacAddress(ip.getMacAddress());
  }
  nic.setIPv4Dns1(dc.getDns1());
  nic.setIPv4Dns2(dc.getDns2());
}

@Override
public void reserve(NicProfile nic, Network config, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context)
  throws InsufficientVirtualNetworkCapacityException, InsufficientAddressCapacityException {
  Pod pod = dest.getPod();
  boolean forSystemVms = vm.getType().equals(VirtualMachine.Type.ConsoleProxy) || vm.getType().equals(VirtualMachine.Type.SecondaryStorageVm);
  PrivateAllocationData result = _dcDao.allocatePrivateIpAddress(dest.getDataCenter().getId(), dest.getPod().getId(), nic.getId(), context.getReservationId(), forSystemVms);
  if (result == null) {
    throw new InsufficientAddressCapacityException("Unable to get a management ip address", Pod.class, pod.getId());
  }
  Integer vlan = result.getVlan();
  nic.setIPv4Address(result.getIpAddress());
  nic.setMacAddress(NetUtils.long2Mac(NetUtils.createSequenceBasedMacAddress(result.getMacAddress(), NetworkModel.MACIdentifier.value())));
  nic.setIPv4Gateway(pod.getGateway());
  nic.setFormat(AddressFormat.Ip4);
  String netmask = NetUtils.getCidrNetmask(pod.getCidrSize());
  nic.setIPv4Netmask(netmask);
  nic.setBroadcastType(BroadcastDomainType.Native);
  if (vlan != null) {
    nic.setBroadcastUri(BroadcastDomainType.Native.toUri(vlan));
  } else {
    nic.setBroadcastUri(null);
  }
  nic.setIsolationUri(null);
  s_logger.debug("Allocated a nic " + nic + " for " + vm);
}

final String netmask = NetUtils.getCidrNetmask(privateNetwork.getCidr());
final PrivateIpAddress ip =
    new PrivateIpAddress(ipVO, privateNetwork.getBroadcastUri().toString(), privateNetwork.getGateway(), netmask,