1 /*
   2  * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.net;
  27 
  28 import java.util.Arrays;
  29 import java.util.Enumeration;
  30 import java.util.NoSuchElementException;
  31 import java.security.AccessController;
  32 import java.util.Spliterator;
  33 import java.util.Spliterators;
  34 import java.util.stream.Stream;
  35 import java.util.stream.StreamSupport;
  36 
  37 /**
  38  * This class represents a Network Interface made up of a name,
  39  * and a list of IP addresses assigned to this interface.
  40  * It is used to identify the local interface on which a multicast group
  41  * is joined.
  42  *
  43  * Interfaces are normally known by names such as "le0".
  44  *
  45  * @since 1.4
  46  */
  47 public final class NetworkInterface {
  48     private String name;
  49     private String displayName;
  50     private int index;
  51     private InetAddress addrs[];
  52     private InterfaceAddress bindings[];
  53     private NetworkInterface childs[];
  54     private NetworkInterface parent = null;
  55     private boolean virtual = false;
  56     private static final NetworkInterface defaultInterface;
  57     private static final int defaultIndex; /* index of defaultInterface */
  58 
  59     static {
  60         AccessController.doPrivileged(
  61             new java.security.PrivilegedAction<>() {
  62                 public Void run() {
  63                     System.loadLibrary("net");
  64                     return null;
  65                 }
  66             });
  67 
  68         init();
  69         defaultInterface = DefaultInterface.getDefault();
  70         if (defaultInterface != null) {
  71             defaultIndex = defaultInterface.getIndex();
  72         } else {
  73             defaultIndex = 0;
  74         }
  75     }
  76 
  77     /**
  78      * Returns an NetworkInterface object with index set to 0 and name to null.
  79      * Setting such an interface on a MulticastSocket will cause the
  80      * kernel to choose one interface for sending multicast packets.
  81      *
  82      */
  83     NetworkInterface() {
  84     }
  85 
  86     NetworkInterface(String name, int index, InetAddress[] addrs) {
  87         this.name = name;
  88         this.index = index;
  89         this.addrs = addrs;
  90     }
  91 
  92     /**
  93      * Get the name of this network interface.
  94      *
  95      * @return the name of this network interface
  96      */
  97     public String getName() {
  98             return name;
  99     }
 100 
 101     /**
 102      * Get an Enumeration with all or a subset of the InetAddresses bound to
 103      * this network interface.
 104      * <p>
 105      * If there is a security manager, its {@code checkConnect}
 106      * method is called for each InetAddress. Only InetAddresses where
 107      * the {@code checkConnect} doesn't throw a SecurityException
 108      * will be returned in the Enumeration. However, if the caller has the
 109      * {@link NetPermission}("getNetworkInformation") permission, then all
 110      * InetAddresses are returned.
 111      *
 112      * @return an Enumeration object with all or a subset of the InetAddresses
 113      * bound to this network interface
 114      * @see #inetAddresses()
 115      */
 116     public Enumeration<InetAddress> getInetAddresses() {
 117         return enumerationFromArray(getCheckedInetAddresses());
 118     }
 119 
 120     /**
 121      * Get a Stream of all or a subset of the InetAddresses bound to this
 122      * network interface.
 123      * <p>
 124      * If there is a security manager, its {@code checkConnect}
 125      * method is called for each InetAddress. Only InetAddresses where
 126      * the {@code checkConnect} doesn't throw a SecurityException will be
 127      * returned in the Stream. However, if the caller has the
 128      * {@link NetPermission}("getNetworkInformation") permission, then all
 129      * InetAddresses are returned.
 130      *
 131      * @return a Stream object with all or a subset of the InetAddresses
 132      * bound to this network interface
 133      * @since 1.9
 134      */
 135     public Stream<InetAddress> inetAddresses() {
 136         return streamFromArray(getCheckedInetAddresses());
 137     }
 138 
 139     private InetAddress[] getCheckedInetAddresses() {
 140         InetAddress[] local_addrs = new InetAddress[addrs.length];
 141         boolean trusted = true;
 142 
 143         SecurityManager sec = System.getSecurityManager();
 144         if (sec != null) {
 145             try {
 146                 sec.checkPermission(new NetPermission("getNetworkInformation"));
 147             } catch (SecurityException e) {
 148                 trusted = false;
 149             }
 150         }
 151         int i = 0;
 152         for (int j = 0; j < addrs.length; j++) {
 153             try {
 154                 if (!trusted) {
 155                     sec.checkConnect(addrs[j].getHostAddress(), -1);
 156                 }
 157                 local_addrs[i++] = addrs[j];
 158             } catch (SecurityException e) { }
 159         }
 160         return Arrays.copyOf(local_addrs, i);
 161     }
 162 
 163     /**
 164      * Get a List of all or a subset of the {@code InterfaceAddresses}
 165      * of this network interface.
 166      * <p>
 167      * If there is a security manager, its {@code checkConnect}
 168      * method is called with the InetAddress for each InterfaceAddress.
 169      * Only InterfaceAddresses where the {@code checkConnect} doesn't throw
 170      * a SecurityException will be returned in the List.
 171      *
 172      * @return a {@code List} object with all or a subset of the
 173      *         InterfaceAddresss of this network interface
 174      * @since 1.6
 175      */
 176     public java.util.List<InterfaceAddress> getInterfaceAddresses() {
 177         java.util.List<InterfaceAddress> lst = new java.util.ArrayList<>(1);
 178         SecurityManager sec = System.getSecurityManager();
 179         for (int j=0; j<bindings.length; j++) {
 180             try {
 181                 if (sec != null) {
 182                     sec.checkConnect(bindings[j].getAddress().getHostAddress(), -1);
 183                 }
 184                 lst.add(bindings[j]);
 185             } catch (SecurityException e) { }
 186         }
 187         return lst;
 188     }
 189 
 190     /**
 191      * Get an Enumeration with all the subinterfaces (also known as virtual
 192      * interfaces) attached to this network interface.
 193      * <p>
 194      * For instance eth0:1 will be a subinterface to eth0.
 195      *
 196      * @return an Enumeration object with all of the subinterfaces
 197      * of this network interface
 198      * @see #subInterfaces()
 199      * @since 1.6
 200      */
 201     public Enumeration<NetworkInterface> getSubInterfaces() {
 202         return enumerationFromArray(childs);
 203     }
 204 
 205     /**
 206      * Get a Stream of all subinterfaces (also known as virtual
 207      * interfaces) attached to this network interface.
 208      *
 209      * @return a Stream object with all of the subinterfaces
 210      * of this network interface
 211      * @since 1.9
 212      */
 213     public Stream<NetworkInterface> subInterfaces() {
 214         return streamFromArray(childs);
 215     }
 216 
 217     /**
 218      * Returns the parent NetworkInterface of this interface if this is
 219      * a subinterface, or {@code null} if it is a physical
 220      * (non virtual) interface or has no parent.
 221      *
 222      * @return The {@code NetworkInterface} this interface is attached to.
 223      * @since 1.6
 224      */
 225     public NetworkInterface getParent() {
 226         return parent;
 227     }
 228 
 229     /**
 230      * Returns the index of this network interface. The index is an integer greater
 231      * or equal to zero, or {@code -1} for unknown. This is a system specific value
 232      * and interfaces with the same name can have different indexes on different
 233      * machines.
 234      *
 235      * @return the index of this network interface or {@code -1} if the index is
 236      *         unknown
 237      * @see #getByIndex(int)
 238      * @since 1.7
 239      */
 240     public int getIndex() {
 241         return index;
 242     }
 243 
 244     /**
 245      * Get the display name of this network interface.
 246      * A display name is a human readable String describing the network
 247      * device.
 248      *
 249      * @return a non-empty string representing the display name of this network
 250      *         interface, or null if no display name is available.
 251      */
 252     public String getDisplayName() {
 253         /* strict TCK conformance */
 254         return "".equals(displayName) ? null : displayName;
 255     }
 256 
 257     /**
 258      * Searches for the network interface with the specified name.
 259      *
 260      * @param   name
 261      *          The name of the network interface.
 262      *
 263      * @return  A {@code NetworkInterface} with the specified name,
 264      *          or {@code null} if there is no network interface
 265      *          with the specified name.
 266      *
 267      * @throws  SocketException
 268      *          If an I/O error occurs.
 269      *
 270      * @throws  NullPointerException
 271      *          If the specified name is {@code null}.
 272      */
 273     public static NetworkInterface getByName(String name) throws SocketException {
 274         if (name == null)
 275             throw new NullPointerException();
 276         return getByName0(name);
 277     }
 278 
 279     /**
 280      * Get a network interface given its index.
 281      *
 282      * @param index an integer, the index of the interface
 283      * @return the NetworkInterface obtained from its index, or {@code null} if
 284      *         there is no interface with such an index on the system
 285      * @throws  SocketException  if an I/O error occurs.
 286      * @throws  IllegalArgumentException if index has a negative value
 287      * @see #getIndex()
 288      * @since 1.7
 289      */
 290     public static NetworkInterface getByIndex(int index) throws SocketException {
 291         if (index < 0)
 292             throw new IllegalArgumentException("Interface index can't be negative");
 293         return getByIndex0(index);
 294     }
 295 
 296     /**
 297      * Convenience method to search for a network interface that
 298      * has the specified Internet Protocol (IP) address bound to
 299      * it.
 300      * <p>
 301      * If the specified IP address is bound to multiple network
 302      * interfaces it is not defined which network interface is
 303      * returned.
 304      *
 305      * @param   addr
 306      *          The {@code InetAddress} to search with.
 307      *
 308      * @return  A {@code NetworkInterface}
 309      *          or {@code null} if there is no network interface
 310      *          with the specified IP address.
 311      *
 312      * @throws  SocketException
 313      *          If an I/O error occurs.
 314      *
 315      * @throws  NullPointerException
 316      *          If the specified address is {@code null}.
 317      */
 318     public static NetworkInterface getByInetAddress(InetAddress addr) throws SocketException {
 319         if (addr == null) {
 320             throw new NullPointerException();
 321         }
 322         if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) {
 323             throw new IllegalArgumentException ("invalid address type");
 324         }
 325         return getByInetAddress0(addr);
 326     }
 327 
 328     /**
 329      * Returns an {@code Enumeration} of all the interfaces on this machine. The
 330      * {@code Enumeration} contains at least one element, possibly representing
 331      * a loopback interface that only supports communication between entities on
 332      * this machine.
 333      *
 334      * @apiNote this method can be used in combination with
 335      * {@link #getInetAddresses()} to obtain all IP addresses for this node
 336      *
 337      * @return an Enumeration of NetworkInterfaces found on this machine
 338      * @exception  SocketException  if an I/O error occurs.
 339      * @see #networkInterfaces()
 340      */
 341     public static Enumeration<NetworkInterface> getNetworkInterfaces()
 342         throws SocketException {
 343         NetworkInterface[] netifs = getAll();
 344         assert netifs != null && netifs.length > 0;
 345 
 346         return enumerationFromArray(netifs);
 347     }
 348 
 349     /**
 350      * Returns a {@code Stream} of all the interfaces on this machine.  The
 351      * {@code Stream} contains at least one interface, possibly representing a
 352      * loopback interface that only supports communication between entities on
 353      * this machine.
 354      *
 355      * @apiNote this method can be used in combination with
 356      * {@link #inetAddresses()}} to obtain a stream of all IP addresses for
 357      * this node, for example:
 358      * <pre> {@code
 359      * Stream<InetAddress> addrs = NetworkInterface.networkInterfaces()
 360      *     .flatMap(NetworkInterface::inetAddresses);
 361      * }</pre>
 362      *
 363      * @return a Stream of NetworkInterfaces found on this machine
 364      * @exception  SocketException  if an I/O error occurs.
 365      * @since 1.9
 366      */
 367     public static Stream<NetworkInterface> networkInterfaces()
 368         throws SocketException {
 369         NetworkInterface[] netifs = getAll();
 370         assert netifs != null && netifs.length > 0;
 371 
 372         return streamFromArray(netifs);
 373     }
 374 
 375     private static <T> Enumeration<T> enumerationFromArray(T[] a) {
 376         return new Enumeration<>() {
 377             int i = 0;
 378 
 379             @Override
 380             public T nextElement() {
 381                 if (i < a.length) {
 382                     return a[i++];
 383                 } else {
 384                     throw new NoSuchElementException();
 385                 }
 386             }
 387 
 388             @Override
 389             public boolean hasMoreElements() {
 390                 return i < a.length;
 391             }
 392         };
 393     }
 394 
 395     private static <T> Stream<T> streamFromArray(T[] a) {
 396         return StreamSupport.stream(
 397                 Spliterators.spliterator(
 398                         a,
 399                         Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL),
 400                 false);
 401     }
 402 
 403     private static native NetworkInterface[] getAll()
 404         throws SocketException;
 405 
 406     private static native NetworkInterface getByName0(String name)
 407         throws SocketException;
 408 
 409     private static native NetworkInterface getByIndex0(int index)
 410         throws SocketException;
 411 
 412     private static native NetworkInterface getByInetAddress0(InetAddress addr)
 413         throws SocketException;
 414 
 415     /**
 416      * Returns whether a network interface is up and running.
 417      *
 418      * @return  {@code true} if the interface is up and running.
 419      * @exception       SocketException if an I/O error occurs.
 420      * @since 1.6
 421      */
 422 
 423     public boolean isUp() throws SocketException {
 424         return isUp0(name, index);
 425     }
 426 
 427     /**
 428      * Returns whether a network interface is a loopback interface.
 429      *
 430      * @return  {@code true} if the interface is a loopback interface.
 431      * @exception       SocketException if an I/O error occurs.
 432      * @since 1.6
 433      */
 434 
 435     public boolean isLoopback() throws SocketException {
 436         return isLoopback0(name, index);
 437     }
 438 
 439     /**
 440      * Returns whether a network interface is a point to point interface.
 441      * A typical point to point interface would be a PPP connection through
 442      * a modem.
 443      *
 444      * @return  {@code true} if the interface is a point to point
 445      *          interface.
 446      * @exception       SocketException if an I/O error occurs.
 447      * @since 1.6
 448      */
 449 
 450     public boolean isPointToPoint() throws SocketException {
 451         return isP2P0(name, index);
 452     }
 453 
 454     /**
 455      * Returns whether a network interface supports multicasting or not.
 456      *
 457      * @return  {@code true} if the interface supports Multicasting.
 458      * @exception       SocketException if an I/O error occurs.
 459      * @since 1.6
 460      */
 461 
 462     public boolean supportsMulticast() throws SocketException {
 463         return supportsMulticast0(name, index);
 464     }
 465 
 466     /**
 467      * Returns the hardware address (usually MAC) of the interface if it
 468      * has one and if it can be accessed given the current privileges.
 469      * If a security manager is set, then the caller must have
 470      * the permission {@link NetPermission}("getNetworkInformation").
 471      *
 472      * @return  a byte array containing the address, or {@code null} if
 473      *          the address doesn't exist, is not accessible or a security
 474      *          manager is set and the caller does not have the permission
 475      *          NetPermission("getNetworkInformation")
 476      *
 477      * @exception       SocketException if an I/O error occurs.
 478      * @since 1.6
 479      */
 480     public byte[] getHardwareAddress() throws SocketException {
 481         SecurityManager sec = System.getSecurityManager();
 482         if (sec != null) {
 483             try {
 484                 sec.checkPermission(new NetPermission("getNetworkInformation"));
 485             } catch (SecurityException e) {
 486                 if (!getInetAddresses().hasMoreElements()) {
 487                     // don't have connect permission to any local address
 488                     return null;
 489                 }
 490             }
 491         }
 492         for (InetAddress addr : addrs) {
 493             if (addr instanceof Inet4Address) {
 494                 return getMacAddr0(((Inet4Address)addr).getAddress(), name, index);
 495             }
 496         }
 497         return getMacAddr0(null, name, index);
 498     }
 499 
 500     /**
 501      * Returns the Maximum Transmission Unit (MTU) of this interface.
 502      *
 503      * @return the value of the MTU for that interface.
 504      * @exception       SocketException if an I/O error occurs.
 505      * @since 1.6
 506      */
 507     public int getMTU() throws SocketException {
 508         return getMTU0(name, index);
 509     }
 510 
 511     /**
 512      * Returns whether this interface is a virtual interface (also called
 513      * subinterface).
 514      * Virtual interfaces are, on some systems, interfaces created as a child
 515      * of a physical interface and given different settings (like address or
 516      * MTU). Usually the name of the interface will the name of the parent
 517      * followed by a colon (:) and a number identifying the child since there
 518      * can be several virtual interfaces attached to a single physical
 519      * interface.
 520      *
 521      * @return {@code true} if this interface is a virtual interface.
 522      * @since 1.6
 523      */
 524     public boolean isVirtual() {
 525         return virtual;
 526     }
 527 
 528     private static native boolean isUp0(String name, int ind) throws SocketException;
 529     private static native boolean isLoopback0(String name, int ind) throws SocketException;
 530     private static native boolean supportsMulticast0(String name, int ind) throws SocketException;
 531     private static native boolean isP2P0(String name, int ind) throws SocketException;
 532     private static native byte[] getMacAddr0(byte[] inAddr, String name, int ind) throws SocketException;
 533     private static native int getMTU0(String name, int ind) throws SocketException;
 534 
 535     /**
 536      * Compares this object against the specified object.
 537      * The result is {@code true} if and only if the argument is
 538      * not {@code null} and it represents the same NetworkInterface
 539      * as this object.
 540      * <p>
 541      * Two instances of {@code NetworkInterface} represent the same
 542      * NetworkInterface if both name and addrs are the same for both.
 543      *
 544      * @param   obj   the object to compare against.
 545      * @return  {@code true} if the objects are the same;
 546      *          {@code false} otherwise.
 547      * @see     java.net.InetAddress#getAddress()
 548      */
 549     public boolean equals(Object obj) {
 550         if (!(obj instanceof NetworkInterface)) {
 551             return false;
 552         }
 553         NetworkInterface that = (NetworkInterface)obj;
 554         if (this.name != null ) {
 555             if (!this.name.equals(that.name)) {
 556                 return false;
 557             }
 558         } else {
 559             if (that.name != null) {
 560                 return false;
 561             }
 562         }
 563 
 564         if (this.addrs == null) {
 565             return that.addrs == null;
 566         } else if (that.addrs == null) {
 567             return false;
 568         }
 569 
 570         /* Both addrs not null. Compare number of addresses */
 571 
 572         if (this.addrs.length != that.addrs.length) {
 573             return false;
 574         }
 575 
 576         InetAddress[] thatAddrs = that.addrs;
 577         int count = thatAddrs.length;
 578 
 579         for (int i=0; i<count; i++) {
 580             boolean found = false;
 581             for (int j=0; j<count; j++) {
 582                 if (addrs[i].equals(thatAddrs[j])) {
 583                     found = true;
 584                     break;
 585                 }
 586             }
 587             if (!found) {
 588                 return false;
 589             }
 590         }
 591         return true;
 592     }
 593 
 594     public int hashCode() {
 595         return name == null? 0: name.hashCode();
 596     }
 597 
 598     public String toString() {
 599         String result = "name:";
 600         result += name == null? "null": name;
 601         if (displayName != null) {
 602             result += " (" + displayName + ")";
 603         }
 604         return result;
 605     }
 606 
 607     private static native void init();
 608 
 609     /**
 610      * Returns the default network interface of this system
 611      *
 612      * @return the default interface
 613      */
 614     static NetworkInterface getDefault() {
 615         return defaultInterface;
 616     }
 617 }