Java Code Examples for java.net.NetworkInterface#isLoopback()

public static String getBroadcastAddress() {
    System.setProperty("java.net.preferIPv4Stack", "true");
    try {
        for (Enumeration<NetworkInterface> niEnum = NetworkInterface.getNetworkInterfaces(); niEnum
                .hasMoreElements();) {
            NetworkInterface ni = niEnum.nextElement();
            if (!ni.isLoopback()) {
                for (InterfaceAddress interfaceAddress : ni.getInterfaceAddresses()) {
                    if (interfaceAddress.getBroadcast() != null) {
                        logger.d(interfaceAddress.getBroadcast().toString().substring(1));
                        return interfaceAddress.getBroadcast().toString().substring(1);
                    }
                }
            }
        }
    }
    catch (SocketException e) {
        e.printStackTrace();
    }

    return null;
}
 

/**
 * Factory method that locates a network interface that has
 * a suitable mac address (ethernet cards, and things that
 * emulate one), and return that address. If there are multiple
 * applicable interfaces, one of them is returned; which one
 * is returned is not specified.
 * Method is meant for accessing an address needed to construct
 * generator for time+location based UUID generation method.
 * 
 * @return Ethernet address of one of interfaces system has;
 *    not including local or loopback addresses; if one exists,
 *    null if no such interfaces are found.
 */
public static EthernetAddress fromInterface()
{
    try {
        Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
        while (en.hasMoreElements()) {
            NetworkInterface nint = en.nextElement();
            if (!nint.isLoopback()) {
                byte[] data = nint.getHardwareAddress();
                if (data != null && data.length == 6) {
                    return new EthernetAddress(data);
                }
            }
        }
    } catch (java.net.SocketException e) {
        // fine, let's take is as signal of not having any interfaces
    }
    return null;
}
 

public static String getIpAddress() {
    try {
        Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
        InetAddress ip;
        while (allNetInterfaces.hasMoreElements()) {
            NetworkInterface netInterface = allNetInterfaces.nextElement();
            if (!netInterface.isLoopback() && !netInterface.isVirtual() && netInterface.isUp()) {
                Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    ip = addresses.nextElement();
                    if (ip instanceof Inet4Address) {
                        LOGGER.info("MediaProxy Server IPAddress:" + ip.getHostAddress());
                        return ip.getHostAddress();
                    }
                }
            }
        }
    } catch (Exception e) {
        LOGGER.error("IP地址获取失败", e);
    }
    return "127.0.0.1";
}
 

public final InetAddress getLocalAddress() throws SocketException {
  for (final Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); interfaces
      .hasMoreElements();) {
    final NetworkInterface networkInterface = interfaces.nextElement();
    if (networkInterface.isLoopback()) {
      continue;
    }
    for (final InterfaceAddress interfaceAddr : networkInterface.getInterfaceAddresses()) {
      final InetAddress inetAddr = interfaceAddr.getAddress();
      if (!(inetAddr instanceof Inet4Address)) {
        continue;
      }
      return inetAddr;
    }
  }
  return null;
}
 

public static int scoreAddr(@NotNull NetworkInterface iface, @NotNull InetAddress addr) {
    int score = 0;

    if (addr instanceof Inet4Address) {
        score += 300;
    }

    try {
        if (!iface.isLoopback() && !addr.isLoopbackAddress()) {
            score += 100;
            if (iface.isUp()) {
                score += 100;
            }
        }
    } catch (SocketException e) {
        logger.error("Unable to score IP {} of interface {}", addr, iface, e);
    }

    return score;
}
 

private static InetAddress getIpAddress(AddressSelectionCondition condition) throws
    SocketException {
  // Before we connect somewhere, we cannot be sure about what we'd be bound to; however,
  // we only connect when the message where client ID is, is long constructed. Thus,
  // just use whichever IP address we can find.
  Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  while (interfaces.hasMoreElements()) {
    NetworkInterface current = interfaces.nextElement();
    if (!current.isUp() || current.isLoopback() || current.isVirtual()) continue;
    Enumeration<InetAddress> addresses = current.getInetAddresses();
    while (addresses.hasMoreElements()) {
      InetAddress addr = addresses.nextElement();
      if (addr.isLoopbackAddress()) continue;
      if (condition.isAcceptableAddress(addr)) {
        return addr;
      }
    }
  }

  throw new SocketException("Can't get our ip address, interfaces are: " + interfaces);
}
 

@Override
public boolean apply(NetworkInterface iface) {
    try {
        if (iface == null) {
            LOG.debug("Ignoring NetworkInterface: null!");
            return false;
        }
        // Bridges claim to be down when no attached interfaces are up. :-(
        // if (false && !iface.isUp()) { LOG.debug("Ignoring NetworkInterface: Down: {}", iface); return false; }
        if (iface.isLoopback()) {
            LOG.debug("Ignoring NetworkInterface: Loopback: {}", iface);
            return false;
        }
        if (iface.isPointToPoint()) {
            LOG.debug("Ignoring NetworkInterface: PointToPoint: {}", iface);
            return false;
        }
        return true;
    } catch (SocketException e) {
        LOG.error("Failed to query " + iface, e);
        return false;
    }
}
 

/**
 * 判断ip地址是不是本机
 * 
 * @param host
 * @return
 */
public static boolean isLocal(String host) {
	try {
		Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
		while (allNetInterfaces.hasMoreElements()) {
			NetworkInterface netInterface = allNetInterfaces.nextElement();

			// 去除回环接口\子接口\未运行接口
			if (netInterface.isLoopback() || netInterface.isVirtual() || !netInterface.isUp()) {
				continue;
			}

			Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
			while (addresses.hasMoreElements()) {
				InetAddress ip = addresses.nextElement();
				if (ip != null) {
					if (ip.getHostAddress().equals(host))
						return true;
				}
			}
		}
	} catch (SocketException e) {
		e.printStackTrace();
	}
	return false;
}
 

private IpAddress findLocalIp() throws SocketException {
    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
    while (interfaces.hasMoreElements()) {
        NetworkInterface iface = interfaces.nextElement();
        if (iface.isLoopback() || iface.isPointToPoint()) {
            continue;
        }

        Enumeration<InetAddress> inetAddresses = iface.getInetAddresses();
        while (inetAddresses.hasMoreElements()) {
            InetAddress inetAddress = inetAddresses.nextElement();
            if (inetAddress instanceof Inet4Address) {
                Inet4Address inet4Address = (Inet4Address) inetAddress;
                try {
                    if (!inet4Address.getHostAddress().equals(InetAddress.getLocalHost().getHostAddress())) {
                        return IpAddress.valueOf(inetAddress);
                    }
                } catch (UnknownHostException e) {
                    return IpAddress.valueOf(inetAddress);
                }
            }
        }
    }
    throw new IllegalStateException("Unable to determine local ip");
}
 

public static String getMyIp() {
    String ip = null;
    try {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface iface = interfaces.nextElement();
            // filters out 127.0.0.1 and inactive interfaces
            if (iface.isLoopback() || !iface.isUp()) {
                continue;
            }

            Enumeration<InetAddress> addresses = iface.getInetAddresses();
            while (addresses.hasMoreElements()) {
                InetAddress addr = addresses.nextElement();
                if (addr instanceof Inet4Address) {
                    ip = addr.getHostAddress();
                    break;
                }
            }
        }
        return ip;
    } catch (SocketException e) {
        return "localhost";
    }
}
 

static List<String> getBroadcastAddress() throws BrowsingException, SocketException {
  Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

  List<String> broadcastAddresses = new ArrayList<>();

  while (interfaces.hasMoreElements()) {
    NetworkInterface networkInterface = interfaces.nextElement();
    if (networkInterface.isLoopback()) {
      continue;
    }

    for (InterfaceAddress interfaceAddress :
            networkInterface.getInterfaceAddresses()) {
      InetAddress broadcast = interfaceAddress.getBroadcast();

      if (broadcast != null) {
        broadcastAddresses.add(broadcast.toString().substring(1));
      }
    }
  }

  return broadcastAddresses;
}
 

private static InetAddress getNonLoopbackNetworkInterfaceAddress(boolean ipv4) throws IOException {
    Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
    while (networkInterfaces.hasMoreElements()) {
        NetworkInterface networkInterface = networkInterfaces.nextElement();
        if (networkInterface.isLoopback() || !networkInterface.isUp()) {
            continue;
        }
        Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
        while (inetAddresses.hasMoreElements()) {
            InetAddress inetAddress = inetAddresses.nextElement();
            if ( (ipv4 && inetAddress instanceof Inet4Address)
                    || (!ipv4 && inetAddress instanceof Inet6Address)) {
                return inetAddress;
            }
        }
    }
    return null;
}
 

/**
 * @deprecated Please use the NetworkAddressService with {@link #getPrimaryIpv4HostAddress()}
 *
 *             Get the first candidate for a local IPv4 host address (non loopback, non localhost).
 */
@Deprecated
public static @Nullable String getLocalIpv4HostAddress() {
    try {
        String hostAddress = null;
        final Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            final NetworkInterface current = interfaces.nextElement();
            if (!current.isUp() || current.isLoopback() || current.isVirtual() || current.isPointToPoint()) {
                continue;
            }
            final Enumeration<InetAddress> addresses = current.getInetAddresses();
            while (addresses.hasMoreElements()) {
                final InetAddress currentAddr = addresses.nextElement();
                if (currentAddr.isLoopbackAddress() || (currentAddr instanceof Inet6Address)) {
                    continue;
                }
                if (hostAddress != null) {
                    LOGGER.warn("Found multiple local interfaces - ignoring {}", currentAddr.getHostAddress());
                } else {
                    hostAddress = currentAddr.getHostAddress();
                }
            }
        }
        return hostAddress;
    } catch (SocketException ex) {
        LOGGER.error("Could not retrieve network interface: {}", ex.getMessage(), ex);
        return null;
    }
}
 

/**
 * Return the ip address.
 * <p>Must hold {@code <uses-permission android:name="android.permission.INTERNET" />}</p>
 *
 * @param useIPv4 True to use ipv4, false otherwise.
 * @return the ip address
 */
@RequiresPermission(INTERNET)
public static String getIPAddress(final boolean useIPv4) {
    try {
        Enumeration<NetworkInterface> nis = NetworkInterface.getNetworkInterfaces();
        LinkedList<InetAddress> adds = new LinkedList<>();
        while (nis.hasMoreElements()) {
            NetworkInterface ni = nis.nextElement();
            // To prevent phone of xiaomi return "10.0.2.15"
            if (!ni.isUp() || ni.isLoopback()) continue;
            Enumeration<InetAddress> addresses = ni.getInetAddresses();
            while (addresses.hasMoreElements()) {
                adds.addFirst(addresses.nextElement());
            }
        }
        for (InetAddress add : adds) {
            if (!add.isLoopbackAddress()) {
                String hostAddress = add.getHostAddress();
                boolean isIPv4 = hostAddress.indexOf(':') < 0;
                if (useIPv4) {
                    if (isIPv4) return hostAddress;
                } else {
                    if (!isIPv4) {
                        int index = hostAddress.indexOf('%');
                        return index < 0
                                ? hostAddress.toUpperCase()
                                : hostAddress.substring(0, index).toUpperCase();
                    }
                }
            }
        }
    } catch (SocketException e) {
        e.printStackTrace();
    }
    return "";
}
 

private static byte[] getHardwareAddress() {
	Enumeration<NetworkInterface> enumeration = null;
	try {
		enumeration = NetworkInterface.getNetworkInterfaces();
	} catch (Exception ex) {
		logger.debug(ex.getMessage(), ex);
	}

	byte[] byteArray = null;
	while (byteArray == null && enumeration != null && enumeration.hasMoreElements()) {
		NetworkInterface element = enumeration.nextElement();

		try {
			if (element.isUp() == false) {
				continue;
			} else if (element.isPointToPoint() || element.isVirtual()) {
				continue;
			} else if (element.isLoopback()) {
				continue;
			}

			byte[] hardwareAddr = element.getHardwareAddress();
			if (hardwareAddr == null || hardwareAddr.length != SIZE_OF_MAC) {
				continue;
			}

			byteArray = new byte[SIZE_OF_MAC];
			System.arraycopy(hardwareAddr, 0, byteArray, 0, SIZE_OF_MAC);
		} catch (Exception rex) {
			logger.debug(rex.getMessage(), rex);
		}
	}

	return byteArray != null ? byteArray : new byte[SIZE_OF_MAC];
}
 

private boolean isLoopBack(NetworkInterface networkInterface) {
    try {
        return networkInterface.isLoopback() || !networkInterface.isUp();
    } catch (SocketException e) {
        return false;
    }
}
 

/**
 * Finds the (non loopback, non localhost) local network interface to be
 * connected to from other machines.
 *
 * @return
 */
public static String getLocalNetworkInterface() {
    String localInterface = null;
    Enumeration<NetworkInterface> interfaces = null;
    try {
        interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface current = interfaces.nextElement();
            if (!current.isUp() || current.isLoopback() || current.isVirtual()) {
                continue;
            }
            Enumeration<InetAddress> addresses = current.getInetAddresses();
            while (addresses.hasMoreElements()) {
                InetAddress current_addr = addresses.nextElement();
                if (current_addr.isLoopbackAddress() || (current_addr instanceof Inet6Address)) {
                    continue;
                }
                if (localInterface != null) {
                    logger.warn("Found multiple local interfaces! Replacing " + localInterface + " with "
                            + current_addr.getHostAddress());
                }
                localInterface = current_addr.getHostAddress();
            }
        }
    } catch (SocketException e) {
        logger.error("Could not retrieve network interface. ", e);
        return null;
    }
    return localInterface;
}
 

public static boolean isValidBindAddress(InetAddress addr) {
	// we don't like them them but have to allow them
	if(addr.isAnyLocalAddress())
		return true;
	try {
		NetworkInterface iface = NetworkInterface.getByInetAddress(addr);
		if(iface == null)
			return false;
		return iface.isUp() && !iface.isLoopback();
	} catch (SocketException e) {
		return false;
	}
}
 

public static boolean isValidBindAddress(InetAddress addr) {
	// we don't like them them but have to allow them
	if(addr.isAnyLocalAddress())
		return true;
	try {
		NetworkInterface iface = NetworkInterface.getByInetAddress(addr);
		if(iface == null)
			return false;
		return iface.isUp() && !iface.isLoopback();
	} catch (SocketException e) {
		return false;
	}
}
 

public void printLocalIpAddresses(){
    String s="";
    try{
        for(Enumeration<NetworkInterface> en=NetworkInterface.getNetworkInterfaces();en.hasMoreElements();){
            NetworkInterface intf=en.nextElement();
            for(Enumeration<InetAddress> enumIpAddr=intf.getInetAddresses();enumIpAddr.hasMoreElements();){
                InetAddress inetAddress=enumIpAddr.nextElement();
                if(!intf.isLoopback()){
                    s+="Interface "+intf.getName()+": "+inetAddress.getHostAddress()+"\n";
                }
            }
        }
        makeText(s,mTextView3);
    }catch(Exception e){e.printStackTrace();}
}