In what instances will Socket.getLocalAddress() be an IPv6 versus an IPv4?

Question

I am writing a Java application that opens a Socket, as follows:

socketConnection = new Socket();
socketConnection.connect(new InetSocketAddress(server, port));

and occasionally performs operations such as reads and writes. One function that is important for sending meta data along with packets is the local and remote addresses of the connection. For example, I am getting the local address bytes as:

public byte[] getLocalIP() {
        InetAddress localAddr = socketConnection.getLocalAddress();
        byte[] addressBytes = localAddr.getAddress();
        return addressBytes;
    }

My protocol would like to have the IPv4 of the sender sent along in the header. However, sometimes this function returns 16 bytes instead of 4, which causes problems. Even more confusing, the behavior sometimes changes within the same run of the program, despite the same Socket object returning IPv4 for previous calls. It is difficult to replicate, I'm still not sure under what circumstances it happens.

Under what circumstances will the above return an IPv6 instead of an IPv4? Is this dependent on the network I'm running on? And what would cause it to shift during the middle of a program execution?

Answer 1

You are creating a Socket object without explicitly binding it locally to an IPv4 or IPv6 address, so it will create and bind an internal IPv4 or IPv6 socket based on whether you connect() to the remote server using an IPv4 or IPv6 address.

If server is an InetAddress, the IP version will be based on whether you use an Inet4Address or Inet6Address.

But if server is a string, it has to be resolved to an InetAddress, and that resolution will depend on whether the string contains a literal IPv4 address, a literal IPv6 address, or a hostname. In the case of literal addresses, the answer is obvious - a literal IPv4 address will resolve into an Inet4Address and a literal IPv6 address will resolve into an Inet6Address. But a hostname can go either way, depending on the result of DNS lookups.

If server is a hostname, and you want to restrict the result to IPv4 only, call InetAddress.getAllByName() directly and loop through the resulting array (a hostname may have multiple IP addresses assigned to it), connect()'ing only to Inet4Address addresses until one of them succeeds:

socketConnection = null;

for(InetAddress addr : InetAddress.getAllByName(server))
{
    if (addr instanceof Inet4Address)
    {
        socketConnection = new Socket();
        try {
            socketConnection.connect(new InetSocketAddress(addr, port));
            break;
        }
        catch (IOException e) {
            socketConnection = null;
        }
    }
}

if (socketConnection == null) {
    throw new ConnectException("Cannot connect to '" + host + "' using IPv4");
}

Answer 2

I was able to determine what causes the problem, although I'm still not sure exactly what is happening under the covers. If the connection is broken server side, and reads from the socket are resulting in Broken pipe errors, then this behavior occurs. See below for how I replicated it:

    Socket s = new Socket();
    String server = "1.2.3.4" // not my real server ip
    s.connect(new InetSocketAddress(server, 9050));
    try{
        System.out.println(s.getLocalAddress().getAddress().length);
        byte[] badData = new byte[100];
        // server application will kill the connection when it cant parse this
        // according to application logic
        Arrays.fill(badData, (byte) 0xFF);
        for(int i = 0; i < 1000; i++){
            OutputStream out = s.getOutputStream();
            out.write(badData);
            out.flush();
            Thread.sleep(1);
        }

    }
    catch(SocketException e){
        System.out.println(e.getMessage());
        System.out.println(s.getLocalAddress().getAddress().length);
    }

Which outputs the following:

4
Broken pipe
16

So, I have figured out what is causing it, but still no insights into why this behavior occurs from Java.