How to Determine Internet Network Interface in Java

Question

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.

Are you running the JAR inside a VM? The VM is its own environment, with its own network interface, which is what Java returns. — blackcompe, Dec 11 '11 at 07:18
No, this is on a Windows 7 machine. I have VMWare installed however, and I believe this is the interface it uses to communicate with the VM. I'm not sure why Java chooses this interface as the default. This behavior is identical on my roommates computer (Windows 7, VMWare installed) — Cavyn VonDeylen, Dec 11 '11 at 07:27
@CavynVonDeylen Please see my updated answer. The code I've posted only prints out my real network interface, while I've Virtual Box's network installed and enabled. — Kohányi Róbert, Dec 11 '11 at 08:11

score 22 · Accepted Answer · edited May 23 '17 at 11:53

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.

This returns the interface I want and the two VMWare interfaces on my computer. The interface I want is first, but I don't really want to rely on that being true all the time. — Cavyn VonDeylen, Dec 11 '11 at 07:48
@CavynVonDeylen If you can describe your use-case we could propose *some sort* of solution. However, there'll be no *clean* way to do this. My first guess is that you should filter the addresses by their IP: throw away addresses *not* starting with `192.168.1`. Yeah, it's *barbaric*. — Kohányi Róbert, Dec 11 '11 at 08:02
Thanks! This code works for me. I'm surprised Java doesn't offer some easy way to do this, as I'd think this would be a fairly common issue. Maybe in Java 8. — Cavyn VonDeylen, Dec 11 '11 at 18:46
@CavynVonDeylen *Maybe in Java 8.* Well, I doubt that. Although I'm not a networking expert, as far as I know you can't set a network interface to be the default at OS level. Only there are applications who can use *some* interface as their default. Basically, if you're to use the code above, will be doing just that: based on some assumption will use an interface as your default. Anyway, I have one more thing to note: maybe the `isReachable(...)` part in the code is superfluous, because the interfaces at that point are *up* and their addresses are local too, so probably you can skip that. — Kohányi Róbert, Dec 11 '11 at 19:35

score 5 · Answer 2 · edited May 23 '17 at 12:33

5

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.

edited May 23 '17 at 12:33

Community

1
1

answered Dec 11 '11 at 07:15

MockerTim

2,416
1
23
31

1

I can come up with an extravagant list of all the interfaces on my machine, but I haven't found any way to programmatically determine which interface is connected to the internet. I'm assuming that if I were to hardcode "net4" for example, which happens to be the correct interface on my machine, this wouldn't hold for other computers running my program. – Cavyn VonDeylen Dec 11 '11 at 07:23

score 2 · Answer 3 · answered Dec 03 '15 at 21:28

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;
}

score 1 · Answer 4 · edited May 11 '18 at 11:50

1

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.

edited May 11 '18 at 11:50

Syscall

16,959
9
22
41

answered May 11 '18 at 11:29

Pauliman

39
4

Returning to this issue and having again checked several forums and talked to admins I have come to the following conclusion. To determine the local interface that has internet access you need to find the one (out of the many) that is in the same network as your gateway. Apparently this can not be determined programmatically using Java as there is not way to find the IP of this gateway. To check for site local interfaces is close but is not reliable enough. So I guess you cannot determine which interface is conected to the internet using Java. – Pauliman Dec 06 '18 at 18:20
address :- /127.0.0.1 isSiteLocal :- false for 127 I am getting not local. How is this possible – P Satish Patro May 30 '20 at 10:21
1

@P Satish Patro There are three reserved ranges of IP addresses that would return true if you checked them with isSiteLocal() : 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16. The loopback interface is special because it is used to address yourself without caring which address has been assigned to your host and regardless of whether the assigned address is part of one of these 3 private ranges or routable via the internet. To make it short, it is not part of one of the 3 IP address ranges, and therefore it will return false. – Pauliman Jun 01 '20 at 19:37

How to Determine Internet Network Interface in Java

4 Answers4

Linked