android-12.0.0_r34/s

/*
 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.net;

import android.system.ErrnoException;

import java.io.FileDescriptor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

import android.system.StructIfaddrs;
import libcore.io.IoUtils;
import libcore.io.Libcore;
import sun.security.action.*;
import java.security.AccessController;

import static android.system.OsConstants.*;

// Android-note: NetworkInterface has been rewritten to avoid native code.
// Fix upstream bug not returning link-down interfaces. http://b/26238832
// Android-added: Document restrictions for targetSdkVersion >= R. http://b/141455849
/**
 * This class represents a Network Interface made up of a name,
 * and a list of IP addresses assigned to this interface.
 * It is used to identify the local interface on which a multicast group
 * is joined.
 *
 * Interfaces are normally known by names such as "le0".
 * <p>
 * <a name="access-restrictions"></a>Note that information about
 * {@link NetworkInterface}s may be restricted. For example, non-system apps
 * with {@code targetSdkVersion >= android.os.Build.VERSION_CODES.R} will only
 * have access to information about {@link NetworkInterface}s that are
 * associated with an {@link InetAddress}.
 *
 * @since 1.4
 */
public final class NetworkInterface {
    private String name;
    private String displayName;
    private int index;
    private InetAddress addrs[];
    private InterfaceAddress bindings[];
    // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
    // private NetworkInterface childs[];
    private List<NetworkInterface> childs;
    private NetworkInterface parent = null;
    private boolean virtual = false;
    private static final NetworkInterface defaultInterface;
    private static final int defaultIndex; /* index of defaultInterface */

    // Android-changed: Fix upstream bug not returning link-down interfaces. http://b/26238832
    private byte[] hardwareAddr;

    static {
        // Android-removed: Android doesn't need to call native init.
        /*
        AccessController.doPrivileged(
            new java.security.PrivilegedAction<Void>() {
                public Void run() {
                    System.loadLibrary("net");
                    return null;
                }
            });

        init();
        */
        defaultInterface = DefaultInterface.getDefault();
        if (defaultInterface != null) {
            defaultIndex = defaultInterface.getIndex();
        } else {
            defaultIndex = 0;
        }
    }

    /**
     * Returns an NetworkInterface object with index set to 0 and name to null.
     * Setting such an interface on a MulticastSocket will cause the
     * kernel to choose one interface for sending multicast packets.
     *
     */
    NetworkInterface() {
    }

    NetworkInterface(String name, int index, InetAddress[] addrs) {
        this.name = name;
        this.index = index;
        this.addrs = addrs;
    }

    /**
     * Get the name of this network interface.
     *
     * @return the name of this network interface
     */
    public String getName() {
            return name;
    }

    /**
     * Convenience method to return an Enumeration with all or a
     * subset of the InetAddresses bound to this network interface.
     * <p>
     * If there is a security manager, its {@code checkConnect}
     * method is called for each InetAddress. Only InetAddresses where
     * the {@code checkConnect} doesn't throw a SecurityException
     * will be returned in the Enumeration. However, if the caller has the
     * {@link NetPermission}("getNetworkInformation") permission, then all
     * InetAddresses are returned.
     * @return an Enumeration object with all or a subset of the InetAddresses
     * bound to this network interface
     */
    public Enumeration<InetAddress> getInetAddresses() {

        class checkedAddresses implements Enumeration<InetAddress> {

            private int i=0, count=0;
            private InetAddress local_addrs[];

            checkedAddresses() {
                local_addrs = new InetAddress[addrs.length];
                boolean trusted = true;

                SecurityManager sec = System.getSecurityManager();
                if (sec != null) {
                    try {
                        sec.checkPermission(new NetPermission("getNetworkInformation"));
                    } catch (SecurityException e) {
                        trusted = false;
                    }
                }
                for (int j=0; j<addrs.length; j++) {
                    try {
                        if (sec != null && !trusted) {
                            sec.checkConnect(addrs[j].getHostAddress(), -1);
                        }
                        local_addrs[count++] = addrs[j];
                    } catch (SecurityException e) { }
                }

            }

            public InetAddress nextElement() {
                if (i < count) {
                    return local_addrs[i++];
                } else {
                    throw new NoSuchElementException();
                }
            }

            public boolean hasMoreElements() {
                return (i < count);
            }
        }
        return new checkedAddresses();

    }

    /**
     * Get a List of all or a subset of the {@code InterfaceAddresses}
     * of this network interface.
     * <p>
     * If there is a security manager, its {@code checkConnect}
     * method is called with the InetAddress for each InterfaceAddress.
     * Only InterfaceAddresses where the {@code checkConnect} doesn't throw
     * a SecurityException will be returned in the List.
     *
     * @return a {@code List} object with all or a subset of the
     *         InterfaceAddresss of this network interface
     * @since 1.6
     */
    public java.util.List<InterfaceAddress> getInterfaceAddresses() {
        java.util.List<InterfaceAddress> lst = new java.util.ArrayList<InterfaceAddress>(1);
        // BEGIN Android-changed: Cherry-picked upstream OpenJDK9 change rev 59a110a38cea
        // http://b/30628919
        if (bindings != null) {
            SecurityManager sec = System.getSecurityManager();
            for (int j=0; j<bindings.length; j++) {
                try {
                    if (sec != null) {
                        sec.checkConnect(bindings[j].getAddress().getHostAddress(), -1);
                    }
                    lst.add(bindings[j]);
                } catch (SecurityException e) { }
            }
        }
        // END Android-changed: Cherry-picked upstream OpenJDK9 change rev 59a110a38cea
        return lst;
    }

    /**
     * Get an Enumeration with all the subinterfaces (also known as virtual
     * interfaces) attached to this network interface.
     * <p>
     * For instance eth0:1 will be a subinterface to eth0.
     *
     * @return an Enumeration object with all of the subinterfaces
     * of this network interface
     * @since 1.6
     */
    public Enumeration<NetworkInterface> getSubInterfaces() {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        return Collections.enumeration(childs);
    }

    /**
     * Returns the parent NetworkInterface of this interface if this is
     * a subinterface, or {@code null} if it is a physical
     * (non virtual) interface or has no parent.
     *
     * @return The {@code NetworkInterface} this interface is attached to.
     * @since 1.6
     */
    public NetworkInterface getParent() {
        return parent;
    }

    /**
     * Returns the index of this network interface. The index is an integer greater
     * or equal to zero, or {@code -1} for unknown. This is a system specific value
     * and interfaces with the same name can have different indexes on different
     * machines.
     *
     * @return the index of this network interface or {@code -1} if the index is
     *         unknown
     * @see #getByIndex(int)
     * @since 1.7
     */
    public int getIndex() {
        return index;
    }

    /**
     * Get the display name of this network interface.
     * A display name is a human readable String describing the network
     * device.
     *
     * @return a non-empty string representing the display name of this network
     *         interface, or null if no display name is available.
     */
    public String getDisplayName() {
        /* strict TCK conformance */
        return "".equals(displayName) ? null : displayName;
    }

    // Android-added: Document restrictions for targetSdkVersion >= R. http://b/141455849
    /**
     * Searches for the network interface with the specified name.
     *
     * @param   name
     *          The name of the network interface.
     *
     * @return  A {@code NetworkInterface} with the specified name,
     *          or {@code null} if the network interface with the specified
     *          name does not exist or <a href="#access-restrictions">can't be
     *          accessed</a>.
     *
     * @throws  SocketException
     *          If an I/O error occurs.
     *
     * @throws  NullPointerException
     *          If the specified name is {@code null}.
     */
    public static NetworkInterface getByName(String name) throws SocketException {
        if (name == null)
            throw new NullPointerException();

        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        NetworkInterface[] nis = getAll();
        for (NetworkInterface ni : nis) {
            if (ni.getName().equals(name)) {
                return ni;
            }
        }
        return null;
    }

    // Android-added: Document restrictions for targetSdkVersion >= R. http://b/141455849
    /**
     * Get a network interface given its index.
     *
     * @param index an integer, the index of the interface
     * @return the NetworkInterface obtained from its index, or {@code null} if
     *         an interface with the specified index does not exist or
     *         <a href="#access-restrictions">can't be accessed</a>.
     * @throws  SocketException  if an I/O error occurs.
     * @throws  IllegalArgumentException if index has a negative value
     * @see #getIndex()
     * @since 1.7
     */
    public static NetworkInterface getByIndex(int index) throws SocketException {
        if (index < 0)
            throw new IllegalArgumentException("Interface index can't be negative");

        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        NetworkInterface[] nis = getAll();
        for (NetworkInterface ni : nis) {
            if (ni.getIndex() == index) {
                return ni;
            }
        }
        return null;
    }

    /**
     * Convenience method to search for a network interface that
     * has the specified Internet Protocol (IP) address bound to
     * it.
     * <p>
     * If the specified IP address is bound to multiple network
     * interfaces it is not defined which network interface is
     * returned.
     *
     * @param   addr
     *          The {@code InetAddress} to search with.
     *
     * @return  A {@code NetworkInterface}
     *          or {@code null} if there is no network interface
     *          with the specified IP address.
     *
     * @throws  SocketException
     *          If an I/O error occurs.
     *
     * @throws  NullPointerException
     *          If the specified address is {@code null}.
     */
    public static NetworkInterface getByInetAddress(InetAddress addr) throws SocketException {
        if (addr == null) {
            throw new NullPointerException();
        }
        if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) {
            throw new IllegalArgumentException ("invalid address type");
        }

        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        NetworkInterface[] nis = getAll();
        for (NetworkInterface ni : nis) {
            for (InetAddress inetAddress : Collections.list(ni.getInetAddresses())) {
                if (inetAddress.equals(addr)) {
                    return ni;
                }
            }
        }
        return null;
    }

    // Android-added: Document restrictions for targetSdkVersion >= R. http://b/141455849
    /**
     * Returns all the interfaces on this machine. The {@code Enumeration}
     * contains at least one element, possibly representing a loopback
     * interface that only supports communication between entities on
     * this machine.
     *
     * NOTE: can use getNetworkInterfaces()+getInetAddresses()
     *       to obtain all IP addresses for this node
     * <p>
     * For non-system apps with
     * {@code targetSdkVersion >= android.os.Build.VERSION_CODES.R}, this
     * method will only return information for {@link NetworkInterface}s that
     * are associated with an {@link InetAddress}.
     *
     * @return an Enumeration of NetworkInterfaces found on this machine
     *         that <a href="#access-restrictions">are accessible</a>.
     * @exception  SocketException  if an I/O error occurs.
     */

    public static Enumeration<NetworkInterface> getNetworkInterfaces()
        throws SocketException {
        final NetworkInterface[] netifs = getAll();
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        // // specified to return null if no network interfaces
        // if (netifs == null)
        if (netifs.length == 0)
            return null;

        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        /*
        return new Enumeration<NetworkInterface>() {
            private int i = 0;
            public NetworkInterface nextElement() {
                if (netifs != null && i < netifs.length) {
                    NetworkInterface netif = netifs[i++];
                    return netif;
                } else {
                    throw new NoSuchElementException();
                }
            }

            public boolean hasMoreElements() {
                return (netifs != null && i < netifs.length);
            }
        };
        */
        return Collections.enumeration(Arrays.asList(netifs));
    }

    // BEGIN Android-changed: Rewrote NetworkInterface on top of Libcore.io.
    // private native static NetworkInterface[] getAll()
    //    throws SocketException;
    private static NetworkInterface[] getAll() throws SocketException {
        // Group Ifaddrs by interface name.
        Map<String, List<StructIfaddrs>> inetMap = new HashMap<>();

        StructIfaddrs[] ifaddrs;
        try {
            ifaddrs = Libcore.os.getifaddrs();
        } catch (ErrnoException e) {
            throw e.rethrowAsSocketException();
        }

        for (StructIfaddrs ifa : ifaddrs) {
            String name = ifa.ifa_name;

            List<StructIfaddrs> ifas;
            if ((ifas = inetMap.get(name)) == null) {
                ifas = new ArrayList<>();
                inetMap.put(name, ifas);
            }

            ifas.add(ifa);
        }

        // Populate NetworkInterface instances.
        Map<String, NetworkInterface> nis = new HashMap<>(inetMap.size());
        for (Map.Entry<String, List<StructIfaddrs>> e : inetMap.entrySet()) {
            String name = e.getKey();
            int index = Libcore.os.if_nametoindex(e.getKey());
            if (index == 0) {
                // This interface has gone away between getifaddrs and if_nametoindex
                continue;
            }

            NetworkInterface ni = new NetworkInterface(name, index, null);
            ni.displayName = name;

            List<InetAddress> addrs = new ArrayList<>();
            List<InterfaceAddress> binds = new ArrayList<>();

            for (StructIfaddrs ifa : e.getValue()) {
                if (ifa.ifa_addr != null) {
                    addrs.add(ifa.ifa_addr);
                    binds.add(new InterfaceAddress(ifa.ifa_addr, (Inet4Address) ifa.ifa_broadaddr,
                                                   ifa.ifa_netmask));
                }

                if (ifa.hwaddr != null) {
                    ni.hardwareAddr = ifa.hwaddr;
                }
            }

            ni.addrs = addrs.toArray(new InetAddress[addrs.size()]);
            ni.bindings = binds.toArray(new InterfaceAddress[binds.size()]);
            ni.childs = new ArrayList<>(0);
            nis.put(name, ni);
        }

        // Populate childs/parent.
        for (Map.Entry<String, NetworkInterface> e : nis.entrySet()) {
            NetworkInterface ni = e.getValue();
            String niName = ni.getName();
            int colonIdx = niName.indexOf(':');
            if (colonIdx != -1) {
                // This is a virtual interface.
                String parentName = niName.substring(0, colonIdx);
                NetworkInterface parent = nis.get(parentName);

                ni.virtual = true;

                if (parent != null) {
                    ni.parent = parent;
                    parent.childs.add(ni);
                }
            }
        }

        return nis.values().toArray(new NetworkInterface[nis.size()]);
    }
    // END Android-changed: Rewrote NetworkInterface on top of Libcore.io.

    /**
     * Returns whether a network interface is up and running.
     *
     * @return  {@code true} if the interface is up and running.
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */

    public boolean isUp() throws SocketException {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        final int mask = IFF_UP | IFF_RUNNING;
        return (getFlags() & mask) == mask;
    }

    /**
     * Returns whether a network interface is a loopback interface.
     *
     * @return  {@code true} if the interface is a loopback interface.
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */

    public boolean isLoopback() throws SocketException {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        return (getFlags() & IFF_LOOPBACK) != 0;
    }

    /**
     * Returns whether a network interface is a point to point interface.
     * A typical point to point interface would be a PPP connection through
     * a modem.
     *
     * @return  {@code true} if the interface is a point to point
     *          interface.
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */

    public boolean isPointToPoint() throws SocketException {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        return (getFlags() & IFF_POINTOPOINT) != 0;
    }

    /**
     * Returns whether a network interface supports multicasting or not.
     *
     * @return  {@code true} if the interface supports Multicasting.
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */

    public boolean supportsMulticast() throws SocketException {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        return (getFlags() & IFF_MULTICAST) != 0;
    }

    // Android-added: Document restrictions for targetSdkVersion >= R. http://b/141455849
    /**
     * Returns the hardware address (usually MAC) of the interface if it
     * has one and if it can be accessed given the current privileges.
     * If a security manager is set, then the caller must have
     * the permission {@link NetPermission}("getNetworkInformation").
     *
     * @return  a byte array containing the address, or {@code null} if
     *          the address doesn't exist, is not accessible or a security
     *          manager is set and the caller does not have the permission
     *          NetPermission("getNetworkInformation"). For example, this
     *          method will generally return {@code null} when called by
     *          non-system apps having
     *          {@code targetSdkVersion >= android.os.Build.VERSION_CODES.R}.
     *
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */
    public byte[] getHardwareAddress() throws SocketException {
        // BEGIN Android-changed: Fix upstream not returning link-down interfaces. http://b/26238832
        /*
        for (InetAddress addr : addrs) {
            if (addr instanceof Inet4Address) {
                return getMacAddr0(((Inet4Address)addr).getAddress(), name, index);
            }
        }
        return getMacAddr0(null, name, index);
         */
        NetworkInterface ni = getByName(name);
        if (ni == null) {
            throw new SocketException("NetworkInterface doesn't exist anymore");
        }
        return ni.hardwareAddr;
        // END Android-changed: Fix upstream not returning link-down interfaces. http://b/26238832
    }

    /**
     * Returns the Maximum Transmission Unit (MTU) of this interface.
     *
     * @return the value of the MTU for that interface.
     * @exception       SocketException if an I/O error occurs.
     * @since 1.6
     */
    public int getMTU() throws SocketException {
        // Android-changed: Rewrote NetworkInterface on top of Libcore.io.
        // return getMTU0(name, index);
        FileDescriptor fd = null;
        try {
            fd = Libcore.rawOs.socket(AF_INET, SOCK_DGRAM, 0);
            return Libcore.rawOs.ioctlMTU(fd, name);
        } catch (ErrnoException e) {
            throw e.rethrowAsSocketException();
        } catch (Exception ex) {
            throw new SocketException(ex);
        } finally {
            IoUtils.closeQuietly(fd);
        }
    }

    /**
     * Returns whether this interface is a virtual interface (also called
     * subinterface).
     * 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 {@code true} if this interface is a virtual interface.
     * @since 1.6
     */
    public boolean isVirtual() {
        return virtual;
    }

    // BEGIN Android-removed: Rewrote NetworkInterface on top of Libcore.io.
    /*
    private native static boolean isUp0(String name, int ind) throws SocketException;
    private native static boolean isLoopback0(String name, int ind) throws SocketException;
    private native static boolean supportsMulticast0(String name, int ind) throws SocketException;
    private native static boolean isP2P0(String name, int ind) throws SocketException;
    private native static byte[] getMacAddr0(byte[] inAddr, String name, int ind) throws SocketException;
    private native static int getMTU0(String name, int ind) throws SocketException;
    */
    // END Android-removed: Rewrote NetworkInterface on top of Libcore.io.

    // BEGIN Android-added: Rewrote NetworkInterface on top of Libcore.io.
    private int getFlags() throws SocketException {
        FileDescriptor fd = null;
        try {
            fd = Libcore.rawOs.socket(AF_INET, SOCK_DGRAM, 0);
            return Libcore.rawOs.ioctlFlags(fd, name);
        } catch (ErrnoException e) {
            throw e.rethrowAsSocketException();
        } catch (Exception ex) {
            throw new SocketException(ex);
        } finally {
            IoUtils.closeQuietly(fd);
        }
    }
    // END Android-added: Rewrote NetworkInterface on top of Libcore.io.

    /**
     * Compares this object against the specified object.
     * The result is {@code true} if and only if the argument is
     * not {@code null} and it represents the same NetworkInterface
     * as this object.
     * <p>
     * Two instances of {@code NetworkInterface} represent the same
     * NetworkInterface if both name and addrs are the same for both.
     *
     * @param   obj   the object to compare against.
     * @return  {@code true} if the objects are the same;
     *          {@code false} otherwise.
     * @see     java.net.InetAddress#getAddress()
     */
    public boolean equals(Object obj) {
        if (!(obj instanceof NetworkInterface)) {
            return false;
        }
        NetworkInterface that = (NetworkInterface)obj;
        if (this.name != null ) {
            if (!this.name.equals(that.name)) {
                return false;
            }
        } else {
            if (that.name != null) {
                return false;
            }
        }

        if (this.addrs == null) {
            return that.addrs == null;
        } else if (that.addrs == null) {
            return false;
        }

        /* Both addrs not null. Compare number of addresses */

        if (this.addrs.length != that.addrs.length) {
            return false;
        }

        InetAddress[] thatAddrs = that.addrs;
        int count = thatAddrs.length;

        for (int i=0; i<count; i++) {
            boolean found = false;
            for (int j=0; j<count; j++) {
                if (addrs[i].equals(thatAddrs[j])) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }

    public int hashCode() {
        return name == null? 0: name.hashCode();
    }

    public String toString() {
        String result = "name:";
        result += name == null? "null": name;
        if (displayName != null) {
            result += " (" + displayName + ")";
        }
        return result;
    }

    // Android-removed: Android doesn't need to call native init.
    // private static native void init();

    /**
     * Returns the default network interface of this system
     *
     * @return the default interface
     */
    static NetworkInterface getDefault() {
        return defaultInterface;
    }
}