All Downloads are FREE. Search and download functionalities are using the official Maven repository.

java.net.NetworkInterface Maven / Gradle / Ivy

There is a newer version: 1.2.9
Show newest version
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/*
 * Copyright (C) 2013 RoboVM AB
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package java.net;

import static libcore.io.OsConstants.*;

import java.io.FileDescriptor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;

import libcore.io.ErrnoException;
import libcore.io.IoUtils;
import libcore.io.Libcore;

/**
 * This class is used to represent a network interface of the local device. An
 * interface is defined by its address and a platform dependent name. The class
 * provides methods to get all information about the available interfaces of the
 * system or to identify the local interface of a joined multicast group.
 */
public final class NetworkInterface extends Object {
    /*
     * BugVM note: This class has been changed heavily to work on Darwin.
     * The original class read all required info from /sys/class/net
     * and /proc/net/if_inet6 and used no native code. Neither of those are 
     * available on Darwin so we need to call native code instead. 
     */
    
    // BugVM note: We need this to do things differently on DARWIN which
    // has neither /sys/class/net nor /proc/net/if_inet6.
    private static final boolean DARWIN;
    
    static {
        String osName = System.getProperty("os.name");
        DARWIN = osName.contains("iOS") || osName.contains("Mac");
    }
    
    private final String name;
    private final int interfaceIndex;
    private final List interfaceAddresses;
    private final List addresses;

    private final List children = new LinkedList();

    private NetworkInterface parent = null;

    private NetworkInterface(String name, int interfaceIndex,
            List addresses, List interfaceAddresses) {
        this.name = name;
        this.interfaceIndex = interfaceIndex;
        this.addresses = addresses;
        this.interfaceAddresses = interfaceAddresses;
    }

    static NetworkInterface forUnboundMulticastSocket() {
        // This is what the RI returns for a MulticastSocket that hasn't been constrained
        // to a specific interface.
        return new NetworkInterface(null, -1,
                Arrays.asList(Inet6Address.ANY), Collections.emptyList());
    }

    /**
     * Returns the index for the network interface, or -1 if unknown.
     * @since 1.7
     */
    public int getIndex() {
        return interfaceIndex;
    }

    /**
     * Returns the name of this network interface (such as "eth0" or "lo").
     */
    public String getName() {
        return name;
    }

    /**
     * Returns an enumeration of the addresses bound to this network interface.
     */
    public Enumeration getInetAddresses() {
        return Collections.enumeration(addresses);
    }

    /**
     * Returns a human-readable name for this network interface. On Android, this is the same
     * string as returned by {@link #getName}.
     */
    public String getDisplayName() {
        return name;
    }

    /**
     * Returns the {@code NetworkInterface} corresponding to the named network interface, or null
     * if no interface has this name.
     *
     * @throws SocketException if an error occurs.
     * @throws NullPointerException if {@code interfaceName == null}.
     */
    public static NetworkInterface getByName(String interfaceName) throws SocketException {
        if (interfaceName == null) {
            throw new NullPointerException("interfaceName == null");
        }

        int interfaceIndex = getInterfaceIndex(interfaceName);
        if (interfaceIndex <= 0) {
            return null;
        }
        List addresses = new ArrayList();
        List interfaceAddresses = new ArrayList();
        collectIpv6Addresses(interfaceName, interfaceIndex, addresses, interfaceAddresses);
        collectIpv4Address(interfaceName, addresses, interfaceAddresses);

        return new NetworkInterface(interfaceName, interfaceIndex, addresses, interfaceAddresses);
    }

    private static int ipv6NetmaskToPrefixLength(byte[] netmask) {
        int prefixLength = 0;
        int index = 0;
        
        // Find the first byte != 0xff
        while (index < netmask.length) {
            int b = netmask[index++] & 0xff;
            if (b != 0xff) {
                break;
            }
            prefixLength += 8;
        }
        
        if (index == netmask.length) {
            return prefixLength;
        }

        byte b = netmask[index];
        // Find the first bit != 1 in b
        for (int bit = 7; bit != 0; bit--) {
            if ((b & (1 << bit)) == 0) {
                break;
            }
            prefixLength++;
        }
        
        return prefixLength;
    }
    
    private static void collectIpv6Addresses(String interfaceName, int interfaceIndex,
            List addresses, List interfaceAddresses) throws SocketException {
        
        // BugVM note: This method used to read from /proc/net/if_inet6 which isn't available on
        // Darwin.
        byte[] bytes = getIpv6Addresses(interfaceName);
        if (bytes != null) {
            for (int i = 0; i < bytes.length; i += 32) {
                byte[] addressBytes = new byte[16];
                byte[] netmaskBytes = new byte[16];
                System.arraycopy(bytes, i, addressBytes, 0, 16);
                System.arraycopy(bytes, i + 16, netmaskBytes, 0, 16);
                Inet6Address inet6Address = new Inet6Address(addressBytes, null, interfaceIndex);
                addresses.add(inet6Address);
                interfaceAddresses.add(new InterfaceAddress(inet6Address, 
                        (short) ipv6NetmaskToPrefixLength(netmaskBytes)));
            }
        }
    }

    private static void collectIpv4Address(String interfaceName, List addresses,
            List interfaceAddresses) throws SocketException {
        // RoboVM note: This method used to use ioctl to probe a socket, this failed in various
        // ways on Darwin.
        byte[] bytes = getIpv4Addresses(interfaceName);
        if (bytes != null) {
            for (int i = 0; i < bytes.length; i += 12) {
                Inet4Address address = new Inet4Address(
                        new byte[] { bytes[i + 0], bytes[i + 1], bytes[i + 2], bytes[i + 3] }, null);
                Inet4Address netmask = new Inet4Address(
                        new byte[] { bytes[i + 4], bytes[i + 5], bytes[i + 6], bytes[i + 7] }, null);
                Inet4Address broadcast = new Inet4Address(
                        new byte[] { bytes[i + 8], bytes[i + 9], bytes[i + 10], bytes[i + 11] }, null);
                addresses.add(address);
                interfaceAddresses.add(new InterfaceAddress(address, broadcast, netmask));
            }
        }
    }

    private static SocketException rethrowAsSocketException(Exception ex) throws SocketException {
        SocketException result = new SocketException();
        result.initCause(ex);
        throw result;
    }

    /**
     * Returns the {@code NetworkInterface} corresponding to the given address, or null if no
     * interface has this address.
     *
     * @throws SocketException if an error occurs.
     * @throws NullPointerException if {@code address == null}.
     */
    public static NetworkInterface getByInetAddress(InetAddress address) throws SocketException {
        if (address == null) {
            throw new NullPointerException("address == null");
        }
        for (NetworkInterface networkInterface : getNetworkInterfacesList()) {
            if (networkInterface.addresses.contains(address)) {
                return networkInterface;
            }
        }
        return null;
    }

    /**
     * Returns the NetworkInterface corresponding to the given interface index, or null if no
     * interface has this index.
     *
     * @throws SocketException if an error occurs.
     * @since 1.7
     */
    public static NetworkInterface getByIndex(int index) throws SocketException {
        String name = Libcore.os.if_indextoname(index);
        if (name == null) {
            return null;
        }
        return NetworkInterface.getByName(name);
    }

    /**
     * Gets a list of all network interfaces available on the local system or
     * {@code null} if no interface is available.
     *
     * @return the list of {@code NetworkInterface} instances representing the
     *         available interfaces.
     * @throws SocketException
     *             if an error occurs while getting the network interface
     *             information.
     */
    public static Enumeration getNetworkInterfaces() throws SocketException {
        return Collections.enumeration(getNetworkInterfacesList());
    }

    /**
     * Returns an array of all available interface names.
     * Added in BugVM.
     */
    private static native String[] getInterfaceNames();
    /**
     * Returns the index of the interface with specified name or 0 if not found. 
     * Added in BugVM.
     */
    private static native int getInterfaceIndex(String interfaceName);
    /**
     * Uses getifaddrs() to retrieve the IPv6 addresses of the interface with
     * the specified name. Returns null if the interface has no
     * IPv6 addresses. Otherwise a byte array is returned with address 1 at 
     * index 0 and its netmask at index 16, address 2 at index 32 and its 
     * netmask at index 48, etc.
     * Added in BugVM.
     */
    private static native byte[] getIpv6Addresses(String interfaceName);
    /**
     * Uses getifaddrs() to retrieve the IPv4 addresses of the interface with
     * the specified name. Returns null if the interface has no
     * IPv4 addresses. Otherwise a byte array is returned with address 1 at
     * index 0 and its netmask at index 4 and its broadcast address at index 8,
     * address 2 at index 12 and its netmask at index 16 and its broadcast address
     * at index 20, etc.
     * Added in BugVM.
     */
    private static native byte[] getIpv4Addresses(String interfaceName);
    /**     * Uses getifaddrs() to retrieve the MAC address of the interface with the
     * specified name.
     * Added in BugVM.
     */
    private static native byte[] getHardwareAddress(String interfaceName);
    /**
     * Returns the flags of the specified interface using ioctl(SIOCGIFFLAGS).
     * Added in BugVM.
     */
    private static native int getFlags(String interfaceName);
    /**
     * Returns the MTU of the specified interface using ioctl(SIOCGIFMTU).
     * Added in BugVM.
     */
    private static native int getMTU(String interfaceName);
    
    @FindBugsSuppressWarnings("DMI_HARDCODED_ABSOLUTE_FILENAME")
    private static List getNetworkInterfacesList() throws SocketException {
        String[] interfaceNames = getInterfaceNames();
        NetworkInterface[] interfaces = new NetworkInterface[interfaceNames.length];
        boolean[] done = new boolean[interfaces.length];
        for (int i = 0; i < interfaceNames.length; ++i) {
            interfaces[i] = NetworkInterface.getByName(interfaceNames[i]);
            // http://b/5833739: getByName can return null if the interface went away between our
            // readdir(2) and our stat(2), so mark interfaces that disappeared as 'done'.
            if (interfaces[i] == null) {
                done[i] = true;
            }
        }

        List result = new ArrayList();
        for (int counter = 0; counter < interfaces.length; counter++) {
            // If this interface has been dealt with already, continue.
            if (done[counter]) {
                continue;
            }

            // Checks whether the following interfaces are children.
            for (int counter2 = counter; counter2 < interfaces.length; counter2++) {
                if (done[counter2]) {
                    continue;
                }
                if (interfaces[counter2].name.startsWith(interfaces[counter].name + ":")) {
                    interfaces[counter].children.add(interfaces[counter2]);
                    interfaces[counter2].parent = interfaces[counter];
                    interfaces[counter].addresses.addAll(interfaces[counter2].addresses);
                    done[counter2] = true;
                }
            }
            result.add(interfaces[counter]);
            done[counter] = true;
        }
        return result;
    }

    /**
     * Compares the specified object to this {@code NetworkInterface} and
     * returns whether they are equal or not. The object must be an instance of
     * {@code NetworkInterface} with the same name, display name, and list
     * of interface addresses.
     *
     * @param obj
     *            the object to compare with this instance.
     * @return {@code true} if the specified object is equal to this {@code
     *         NetworkInterface}, {@code false} otherwise.
     * @see #hashCode()
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof NetworkInterface)) {
            return false;
        }
        NetworkInterface rhs = (NetworkInterface) obj;
        // TODO: should the order of the addresses matter (we use List.equals)?
        return interfaceIndex == rhs.interfaceIndex &&
                name.equals(rhs.name) &&
                addresses.equals(rhs.addresses);
    }

    /**
     * Returns the hash code for this {@code NetworkInterface}. Since the
     * name should be unique for each network interface the hash code is
     * generated using the name.
     */
    @Override public int hashCode() {
        return name.hashCode();
    }

    /**
     * Returns a string containing details of this network interface.
     * The exact format is deliberately unspecified. Callers that require a specific
     * format should build a string themselves, using this class' accessor methods.
     */
    @Override public String toString() {
        StringBuilder sb = new StringBuilder(25);
        sb.append("[");
        sb.append(name);
        sb.append("][");
        sb.append(interfaceIndex);
        sb.append("]");
        for (InetAddress address : addresses) {
            sb.append("[");
            sb.append(address.toString());
            sb.append("]");
        }
        return sb.toString();
    }

    /**
     * Returns a List of the InterfaceAddresses for this network interface.
     * @since 1.6
     */
    public List getInterfaceAddresses() {
        return Collections.unmodifiableList(interfaceAddresses);
    }

    /**
     * Returns an enumeration of all the sub-interfaces of this network interface.
     * Sub-interfaces are also known as virtual interfaces.
     *
     * 

For example, {@code eth0:1} would be a sub-interface of {@code eth0}. * * @return an Enumeration of all the sub-interfaces of this network interface * @since 1.6 */ public Enumeration getSubInterfaces() { return Collections.enumeration(children); } /** * Returns the parent NetworkInterface of this interface if this is a * sub-interface, or null if it's a physical (non virtual) interface. * * @return the NetworkInterface this interface is attached to. * @since 1.6 */ public NetworkInterface getParent() { return parent; } /** * Returns true if this network interface is up. * * @return true if the interface is up. * @throws SocketException if an I/O error occurs. * @since 1.6 */ public boolean isUp() throws SocketException { return hasFlag(IFF_UP); } /** * Returns true if this network interface is a loopback interface. * * @return true if the interface is a loopback interface. * @throws SocketException if an I/O error occurs. * @since 1.6 */ public boolean isLoopback() throws SocketException { return hasFlag(IFF_LOOPBACK); } /** * Returns true if this network interface is a point-to-point interface. * (For example, a PPP connection using a modem.) * * @return true if the interface is point-to-point. * @throws SocketException if an I/O error occurs. * @since 1.6 */ public boolean isPointToPoint() throws SocketException { return hasFlag(IFF_POINTOPOINT); } /** * Returns true if this network interface supports multicast. * * @throws SocketException if an I/O error occurs. * @since 1.6 */ public boolean supportsMulticast() throws SocketException { return hasFlag(IFF_MULTICAST); } private boolean hasFlag(int mask) throws SocketException { // BugVM note: Changed to call native code instead of reading from /sys/class/net int flags = getFlags(name); return (flags & mask) != 0; } /** * Returns the hardware address of the interface, if it has one, or null otherwise. * * @throws SocketException if an I/O error occurs. * @since 1.6 */ public byte[] getHardwareAddress() throws SocketException { // BugVM note: Changed to call native code instead of reading from /sys/class/net return getHardwareAddress(name); } /** * Returns the Maximum Transmission Unit (MTU) of this interface. * * @return the value of the MTU for the interface. * @throws SocketException if an I/O error occurs. * @since 1.6 */ public int getMTU() throws SocketException { // BugVM note: Changed to call native code instead of reading from /sys/class/net return getMTU(name); } /** * Returns true if this interface is a virtual interface (also called * a sub-interface). Virtual interfaces are, on some systems, interfaces * created as a child of a physical interface and given different settings * (like address or MTU). Usually the name of the interface will the name of * the parent followed by a colon (:) and a number identifying the child, * since there can be several virtual interfaces attached to a single * physical interface. * * @return true if this interface is a virtual interface. * @since 1.6 */ public boolean isVirtual() { return parent != null; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy