/*

 * Copyright (c) 2000, 2015, 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 java.util.Arrays;

import java.util.Enumeration;

import java.util.NoSuchElementException;

import java.security.AccessController;

import java.util.Spliterator;

import java.util.Spliterators;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

/**

 * 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".

 *

 * @since 1.4

 */

public final class NetworkInterface {

    private String name;

    private String displayName;

    private int index;

    private InetAddress addrs[];

    private InterfaceAddress bindings[];

    private NetworkInterface childs[];

    private NetworkInterface parent = null;

    private boolean virtual = false;

    private static final NetworkInterface defaultInterface;

    private static final int defaultIndex; /* index of defaultInterface */

    static {

        AccessController.doPrivileged(

            new java.security.PrivilegedAction<>() {

                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;

    }

    /**

     * Get 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

     * @see #inetAddresses()

     */

    public Enumeration<InetAddress> getInetAddresses() {

        return enumerationFromArray(getCheckedInetAddresses());

    }

    /**

     * Get a Stream of 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 Stream. However, if the caller has the

     * {@link NetPermission}("getNetworkInformation") permission, then all

     * InetAddresses are returned.

     *

     * @return a Stream object with all or a subset of the InetAddresses

     * bound to this network interface

     */

    public Stream<InetAddress> inetAddresses() {

        return streamFromArray(getCheckedInetAddresses());

    }

    private InetAddress[] getCheckedInetAddresses() {

        InetAddress[] 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;

            }

        }

        int i = 0;

        for (int j = 0; j < addrs.length; j++) {

            try {

                if (!trusted) {

                    sec.checkConnect(addrs[j].getHostAddress(), -1);

                }

                local_addrs[i++] = addrs[j];

            } catch (SecurityException e) { }

        }

        return Arrays.copyOf(local_addrs, i);

    }

    /**

     * 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<>(1);

        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) { }

        }

        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

     * @see #subInterfaces()

     * @since 1.6

     */

    public Enumeration<NetworkInterface> getSubInterfaces() {

        return enumerationFromArray(childs);

    }

    /**

     * Get a Stream of all subinterfaces (also known as virtual

     * interfaces) attached to this network interface.

     *

     * @return a Stream object with all of the subinterfaces

     * of this network interface

     */

    public Stream<NetworkInterface> subInterfaces() {

        return streamFromArray(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;

    }

    /**

     * 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 there is no network interface

     *          with the specified name.

     *

     * @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();

        return getByName0(name);

    }

    /**

     * 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

     *         there is no interface with such an index on the system

     * @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");

        return getByIndex0(index);

    }

    /**

     * 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");

        }

        return getByInetAddress0(addr);

    }

    /**

     * Returns an {@code Enumeration} of 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.

     *

     * @apiNote this method can be used in combination with

     * {@link #getInetAddresses()} to obtain all IP addresses for this node

     *

     * @return an Enumeration of NetworkInterfaces found on this machine

     * @exception  SocketException  if an I/O error occurs.

     * @see #networkInterfaces()

     */

    public static Enumeration<NetworkInterface> getNetworkInterfaces()

        throws SocketException {

        NetworkInterface[] netifs = getAll();

        assert netifs != null && netifs.length > 0;

        return enumerationFromArray(netifs);

    }

    /**

     * Returns a {@code Stream} of all the interfaces on this machine.  The

     * {@code Stream} contains at least one interface, possibly representing a

     * loopback interface that only supports communication between entities on

     * this machine.

     *

     * @apiNote this method can be used in combination with

     * {@link #inetAddresses()}} to obtain a stream of all IP addresses for

     * this node, for example:

     * <pre> {@code

     * Stream<InetAddress> addrs = NetworkInterface.networkInterfaces()

     *     .flatMap(NetworkInterface::inetAddresses);

     * }</pre>

     *

     * @return a Stream of NetworkInterfaces found on this machine

     * @exception  SocketException  if an I/O error occurs.

     */

    public static Stream<NetworkInterface> networkInterfaces()

        throws SocketException {

        NetworkInterface[] netifs = getAll();

        assert netifs != null && netifs.length > 0;

        return streamFromArray(netifs);

    }

    private static <T> Enumeration<T> enumerationFromArray(T[] a) {

        return new Enumeration<>() {

            int i = 0;

            @Override

            public T nextElement() {

                if (i < a.length) {

                    return a[i++];

                } else {

                    throw new NoSuchElementException();

                }

            }

            @Override

            public boolean hasMoreElements() {

                return i < a.length;

            }

        };

    }

    private static <T> Stream<T> streamFromArray(T[] a) {

        return StreamSupport.stream(

                Spliterators.spliterator(

                        a,

                        Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL),

                false);

    }

    private static native NetworkInterface[] getAll()

        throws SocketException;

    private static native NetworkInterface getByName0(String name)

        throws SocketException;

    private static native NetworkInterface getByIndex0(int index)

        throws SocketException;

    private static native NetworkInterface getByInetAddress0(InetAddress addr)

        throws SocketException;

    /**

     * 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 {

        return isUp0(name, index);

    }

    /**

     * 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 {

        return isLoopback0(name, index);

    }

    /**

     * 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 {

        return isP2P0(name, index);

    }

    /**

     * 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 {

        return supportsMulticast0(name, index);

    }

    /**

     * 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")

     *

     * @exception       SocketException if an I/O error occurs.

     * @since 1.6

     */

    public byte[] getHardwareAddress() throws SocketException {

        SecurityManager sec = System.getSecurityManager();

        if (sec != null) {

            try {

                sec.checkPermission(new NetPermission("getNetworkInformation"));

            } catch (SecurityException e) {

                if (!getInetAddresses().hasMoreElements()) {

                    // don't have connect permission to any local address

                    return null;

                }

            }

        }

        for (InetAddress addr : addrs) {

            if (addr instanceof Inet4Address) {

                return getMacAddr0(((Inet4Address)addr).getAddress(), name, index);

            }

        }

        return getMacAddr0(null, name, index);

    }

    /**

     * 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