How to Determine Internet Network Interface in Java

How do you determine which network interface is connected to the internet using Java? For example, I run

InetAddress.getLocalHost().getHostAddress();

and within Eclipse this returns exactly what I intend, 192.168.1.105. However, if I package this into a jar file and run the program, the code returns 169.254.234.50. Looking into this, I found this is the IP address of a VMware Virtual Ethernet Adapter interface on my machine.

Is there any way to determine the interface connected to the internet, yet at the same time maintain portability for my code?

Comparison of Interfaces

Interface [net4]

display name  : Intel(R) Centrino(R) Ultimate-N 6300 AGN
MTU           : 1500
loopback      : false
point to point: false
up            : true
virtual       : false
multicast     : true
HW address    : 00 24 D7 2C 5F 70 
INET address (IPv4): 192.168.1.105
  host name           : MyComputer
  canonical host name : MyComputer
  loopback            : false
  site local          : true
  any local           : false
  link local          : false
  multicast           : false
  reachable           : true

Interface [eth5]

display name  : VMware Virtual Ethernet Adapter for VMnet1
MTU           : 1500
loopback      : false
point to point: false
up            : true
virtual       : false
multicast     : true
HW address    : 00 50 56 C0 00 01 
INET address (IPv4): 169.254.234.50
  host name           : MyComputer
  canonical host name : MyComputer
  loopback            : false
  site local          : false
  any local           : false
  link local          : true
  multicast           : false
  reachable           : true

There's a third VMware interface with site local=true and link local=false, so those fields aren't any help either.

Kohányi Róbert

On my laptop (running Windows 7, with Virtual Box and it's network interface installed) the following code prints out the name of my wireless interface along with my local address. It uses a brute force approach at the end of the day, but will only try and actually connect to addresses that are considered to be the best candidates.

// iterate over the network interfaces known to java
Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
OUTER : for (NetworkInterface interface_ : Collections.list(interfaces)) {
  // we shouldn't care about loopback addresses
  if (interface_.isLoopback())
    continue;

  // if you don't expect the interface to be up you can skip this
  // though it would question the usability of the rest of the code
  if (!interface_.isUp())
    continue;

  // iterate over the addresses associated with the interface
  Enumeration<InetAddress> addresses = interface_.getInetAddresses();
  for (InetAddress address : Collections.list(addresses)) {
    // look only for ipv4 addresses
    if (address instanceof Inet6Address)
      continue;

    // use a timeout big enough for your needs
    if (!address.isReachable(3000))
      continue;

    // java 7's try-with-resources statement, so that
    // we close the socket immediately after use
    try (SocketChannel socket = SocketChannel.open()) {
      // again, use a big enough timeout
      socket.socket().setSoTimeout(3000);

      // bind the socket to your local interface
      socket.bind(new InetSocketAddress(address, 8080));

      // try to connect to *somewhere*
      socket.connect(new InetSocketAddress("google.com", 80));
    } catch (IOException ex) {
      ex.printStackTrace();
      continue;
    }

    System.out.format("ni: %s, ia: %s\n", interface_, address);

    // stops at the first *working* solution
    break OUTER;
  }
}

_{(I've updated my answer with isReachable(...) based on Mocker Tim's answer.)}

One thing to watch out for. socket.bind(...) would bark at me that the address and port is already in use if I tried to run my code too fast in succession like the connection isn't cleaned up fast enough. 8080 should be a random port maybe.

MockerTim

Take a look at Retrieving Network Interfaces and Listing Network Interface Addresses in the Java Tutorial.

If you have several network interfaces which are up and running, you must select programmatically the network interface that your program should use.

UPDATE:

I've found the question that is similar to yours.
See the answer to how-to-check-if-internet-connection-is-present-in-java.

UPDATE 2:

IMHO You should do the following in your program:

Find all IPv4 network interfaces on the machine that your program is running on;
Ask the user which of them your program should use;
Use the interface, that the user pointed to.

I was having the same problem, and came up with this solution (not as thorough as the answer, but I needed something that didn't try to connect to the internet.

Based on known OUI for mac addresses: http://standards-oui.ieee.org/oui.txt

I made a quick check (could be optimized with binary logic)

private static boolean isVmwareMac(byte[] mac) {
    byte invalidMacs[][] = {
            {0x00, 0x05, 0x69},             //VMWare
            {0x00, 0x1C, 0x14},             //VMWare
            {0x00, 0x0C, 0x29},             //VMWare
            {0x00, 0x50, 0x56}              //VMWare
    };

    for (byte[] invalid: invalidMacs){
        if (invalid[0] == mac[0] && invalid[1] == mac[1] && invalid[2] == mac[2])
            return true;
    }

    return false;
}

Pauliman

I was bugged by the same problem for a quite a bit and eventhough the inital question was asked ages ago I'll append my take on ths issue anyway. The ironic thing is that the answer was provided along with the question.
It is: siteLocal = true
Here is what worked for me

Get all network interfaces

NetworkInterface.getNetworkInterfaces();

Single out those that are currently down (just reduces the number of runs)
```
if(interface.isUp()){}
```
Get the InetAddresses of the interfaces you just singled out
```
interface.getInetAddresses();
```
Check those addresses if they are site local addresses
```
if(inetAddress.isSiteLocal()){}
```

That should give you one/all InetAddress(es) - and the network interface(s) that is/are linked to your local network.
Site local is defined to use addresses from these networks: 10.0.0.0, 172.16.0.0, 192.168.0.0 while VirtualBox adapters and others usually use the 169.254.0.0 link-local addresses. IPv6 also implements the site local concept, so it's best to focus on IPv4 here. On a regular end user machine this should work rather well and return just the one physical interface.

来源：https://stackoverflow.com/questions/8462498/how-to-determine-internet-network-interface-in-java

标签

java

networking

network-interface