rev 55657 : 8227587: Add internal privileged System.loadLibrary
Reviewed-by: rriggs

   1 /*
   2  * Copyright (c) 2000, 2019, 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 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      *         InterfaceAddress 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         if (bindings != null) {
 179             SecurityManager sec = System.getSecurityManager();
 180             for (int j=0; j<bindings.length; j++) {
 181                 try {
 182                     if (sec != null) {
 183                         sec.checkConnect(bindings[j].getAddress().getHostAddress(), -1);
 184                     }
 185                     lst.add(bindings[j]);
 186                 } catch (SecurityException e) { }
 187             }
 188         }
 189         return lst;
 190     }
 191 
 192     /**
 193      * Get an Enumeration with all the subinterfaces (also known as virtual
 194      * interfaces) attached to this network interface.
 195      * <p>
 196      * For instance eth0:1 will be a subinterface to eth0.
 197      *
 198      * @return an Enumeration object with all of the subinterfaces
 199      * of this network interface
 200      * @see #subInterfaces()
 201      * @since 1.6
 202      */
 203     public Enumeration<NetworkInterface> getSubInterfaces() {
 204         return enumerationFromArray(childs);
 205     }
 206 
 207     /**
 208      * Get a Stream of all subinterfaces (also known as virtual
 209      * interfaces) attached to this network interface.
 210      *
 211      * @return a Stream object with all of the subinterfaces
 212      * of this network interface
 213      * @since 9
 214      */
 215     public Stream<NetworkInterface> subInterfaces() {
 216         return streamFromArray(childs);
 217     }
 218 
 219     /**
 220      * Returns the parent NetworkInterface of this interface if this is
 221      * a subinterface, or {@code null} if it is a physical
 222      * (non virtual) interface or has no parent.
 223      *
 224      * @return The {@code NetworkInterface} this interface is attached to.
 225      * @since 1.6
 226      */
 227     public NetworkInterface getParent() {
 228         return parent;
 229     }
 230 
 231     /**
 232      * Returns the index of this network interface. The index is an integer greater
 233      * or equal to zero, or {@code -1} for unknown. This is a system specific value
 234      * and interfaces with the same name can have different indexes on different
 235      * machines.
 236      *
 237      * @return the index of this network interface or {@code -1} if the index is
 238      *         unknown
 239      * @see #getByIndex(int)
 240      * @since 1.7
 241      */
 242     public int getIndex() {
 243         return index;
 244     }
 245 
 246     /**
 247      * Get the display name of this network interface.
 248      * A display name is a human readable String describing the network
 249      * device.
 250      *
 251      * @return a non-empty string representing the display name of this network
 252      *         interface, or null if no display name is available.
 253      */
 254     public String getDisplayName() {
 255         /* strict TCK conformance */
 256         return "".equals(displayName) ? null : displayName;
 257     }
 258 
 259     /**
 260      * Searches for the network interface with the specified name.
 261      *
 262      * @param   name
 263      *          The name of the network interface.
 264      *
 265      * @return  A {@code NetworkInterface} with the specified name,
 266      *          or {@code null} if there is no network interface
 267      *          with the specified name.
 268      *
 269      * @throws  SocketException
 270      *          If an I/O error occurs.
 271      *
 272      * @throws  NullPointerException
 273      *          If the specified name is {@code null}.
 274      */
 275     public static NetworkInterface getByName(String name) throws SocketException {
 276         if (name == null)
 277             throw new NullPointerException();
 278         return getByName0(name);
 279     }
 280 
 281     /**
 282      * Get a network interface given its index.
 283      *
 284      * @param index an integer, the index of the interface
 285      * @return the NetworkInterface obtained from its index, or {@code null} if
 286      *         there is no interface with such an index on the system
 287      * @throws  SocketException  if an I/O error occurs.
 288      * @throws  IllegalArgumentException if index has a negative value
 289      * @see #getIndex()
 290      * @since 1.7
 291      */
 292     public static NetworkInterface getByIndex(int index) throws SocketException {
 293         if (index < 0)
 294             throw new IllegalArgumentException("Interface index can't be negative");
 295         return getByIndex0(index);
 296     }
 297 
 298     /**
 299      * Convenience method to search for a network interface that
 300      * has the specified Internet Protocol (IP) address bound to
 301      * it.
 302      * <p>
 303      * If the specified IP address is bound to multiple network
 304      * interfaces it is not defined which network interface is
 305      * returned.
 306      *
 307      * @param   addr
 308      *          The {@code InetAddress} to search with.
 309      *
 310      * @return  A {@code NetworkInterface}
 311      *          or {@code null} if there is no network interface
 312      *          with the specified IP address.
 313      *
 314      * @throws  SocketException
 315      *          If an I/O error occurs.
 316      *
 317      * @throws  NullPointerException
 318      *          If the specified address is {@code null}.
 319      */
 320     public static NetworkInterface getByInetAddress(InetAddress addr) throws SocketException {
 321         if (addr == null) {
 322             throw new NullPointerException();
 323         }
 324 
 325         if (addr.holder.family == InetAddress.IPv4) {
 326             if (!(addr instanceof Inet4Address)) {
 327                 throw new IllegalArgumentException("invalid family type: "
 328                         + addr.holder.family);
 329             }
 330         } else if (addr.holder.family == InetAddress.IPv6) {
 331             if (!(addr instanceof Inet6Address)) {
 332                 throw new IllegalArgumentException("invalid family type: "
 333                         + addr.holder.family);
 334             }
 335         } else {
 336             throw new IllegalArgumentException("invalid address type: " + addr);
 337         }
 338         return getByInetAddress0(addr);
 339     }
 340 
 341     /**
 342      * Returns an {@code Enumeration} of all the interfaces on this machine. The
 343      * {@code Enumeration} contains at least one element, possibly representing
 344      * a loopback interface that only supports communication between entities on
 345      * this machine.
 346      *
 347      * @apiNote this method can be used in combination with
 348      * {@link #getInetAddresses()} to obtain all IP addresses for this node
 349      *
 350      * @return an Enumeration of NetworkInterfaces found on this machine
 351      * @exception  SocketException  if an I/O error occurs,
 352      *             or if the platform does not have at least one configured
 353      *             network interface.
 354      * @see #networkInterfaces()
 355      */
 356     public static Enumeration<NetworkInterface> getNetworkInterfaces()
 357         throws SocketException {
 358         NetworkInterface[] netifs = getAll();
 359         if (netifs != null && netifs.length > 0) {
 360             return enumerationFromArray(netifs);
 361         } else {
 362             throw new SocketException("No network interfaces configured");
 363         }
 364     }
 365 
 366     /**
 367      * Returns a {@code Stream} of all the interfaces on this machine.  The
 368      * {@code Stream} contains at least one interface, possibly representing a
 369      * loopback interface that only supports communication between entities on
 370      * this machine.
 371      *
 372      * @apiNote this method can be used in combination with
 373      * {@link #inetAddresses()}} to obtain a stream of all IP addresses for
 374      * this node, for example:
 375      * <pre> {@code
 376      * Stream<InetAddress> addrs = NetworkInterface.networkInterfaces()
 377      *     .flatMap(NetworkInterface::inetAddresses);
 378      * }</pre>
 379      *
 380      * @return a Stream of NetworkInterfaces found on this machine
 381      * @exception  SocketException  if an I/O error occurs,
 382      *             or if the platform does not have at least one configured
 383      *             network interface.
 384      * @since 9
 385      */
 386     public static Stream<NetworkInterface> networkInterfaces()
 387         throws SocketException {
 388         NetworkInterface[] netifs = getAll();
 389         if (netifs != null && netifs.length > 0) {
 390             return streamFromArray(netifs);
 391         }  else {
 392             throw new SocketException("No network interfaces configured");
 393         }
 394     }
 395 
 396     /**
 397      * Checks if the given address is bound to any of the interfaces on this
 398      * machine.
 399      *
 400      * @param   addr
 401      *          The {@code InetAddress} to search with.
 402      * @return  true iff the addr parameter is currently bound to one of
 403      *          the interfaces on this machine.
 404      *
 405      * @throws  SocketException
 406      *          If an I/O error occurs.
 407      */
 408     /* package-private */ static boolean isBoundInetAddress(InetAddress addr)
 409         throws SocketException {
 410         return boundInetAddress0(addr);
 411     }
 412 
 413     private static <T> Enumeration<T> enumerationFromArray(T[] a) {
 414         return new Enumeration<>() {
 415             int i = 0;
 416 
 417             @Override
 418             public T nextElement() {
 419                 if (i < a.length) {
 420                     return a[i++];
 421                 } else {
 422                     throw new NoSuchElementException();
 423                 }
 424             }
 425 
 426             @Override
 427             public boolean hasMoreElements() {
 428                 return i < a.length;
 429             }
 430         };
 431     }
 432 
 433     private static <T> Stream<T> streamFromArray(T[] a) {
 434         return StreamSupport.stream(
 435                 Spliterators.spliterator(
 436                         a,
 437                         Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL),
 438                 false);
 439     }
 440 
 441     private static native NetworkInterface[] getAll()
 442         throws SocketException;
 443 
 444     private static native NetworkInterface getByName0(String name)
 445         throws SocketException;
 446 
 447     private static native NetworkInterface getByIndex0(int index)
 448         throws SocketException;
 449 
 450     private static native boolean boundInetAddress0(InetAddress addr)
 451             throws SocketException;
 452 
 453     private static native NetworkInterface getByInetAddress0(InetAddress addr)
 454         throws SocketException;
 455 
 456     /**
 457      * Returns whether a network interface is up and running.
 458      *
 459      * @return  {@code true} if the interface is up and running.
 460      * @exception       SocketException if an I/O error occurs.
 461      * @since 1.6
 462      */
 463 
 464     public boolean isUp() throws SocketException {
 465         return isUp0(name, index);
 466     }
 467 
 468     /**
 469      * Returns whether a network interface is a loopback interface.
 470      *
 471      * @return  {@code true} if the interface is a loopback interface.
 472      * @exception       SocketException if an I/O error occurs.
 473      * @since 1.6
 474      */
 475 
 476     public boolean isLoopback() throws SocketException {
 477         return isLoopback0(name, index);
 478     }
 479 
 480     /**
 481      * Returns whether a network interface is a point to point interface.
 482      * A typical point to point interface would be a PPP connection through
 483      * a modem.
 484      *
 485      * @return  {@code true} if the interface is a point to point
 486      *          interface.
 487      * @exception       SocketException if an I/O error occurs.
 488      * @since 1.6
 489      */
 490 
 491     public boolean isPointToPoint() throws SocketException {
 492         return isP2P0(name, index);
 493     }
 494 
 495     /**
 496      * Returns whether a network interface supports multicasting or not.
 497      *
 498      * @return  {@code true} if the interface supports Multicasting.
 499      * @exception       SocketException if an I/O error occurs.
 500      * @since 1.6
 501      */
 502 
 503     public boolean supportsMulticast() throws SocketException {
 504         return supportsMulticast0(name, index);
 505     }
 506 
 507     /**
 508      * Returns the hardware address (usually MAC) of the interface if it
 509      * has one and if it can be accessed given the current privileges.
 510      * If a security manager is set, then the caller must have
 511      * the permission {@link NetPermission}("getNetworkInformation").
 512      *
 513      * @return  a byte array containing the address, or {@code null} if
 514      *          the address doesn't exist, is not accessible or a security
 515      *          manager is set and the caller does not have the permission
 516      *          NetPermission("getNetworkInformation")
 517      *
 518      * @exception       SocketException if an I/O error occurs.
 519      * @since 1.6
 520      */
 521     public byte[] getHardwareAddress() throws SocketException {
 522         SecurityManager sec = System.getSecurityManager();
 523         if (sec != null) {
 524             try {
 525                 sec.checkPermission(new NetPermission("getNetworkInformation"));
 526             } catch (SecurityException e) {
 527                 if (!getInetAddresses().hasMoreElements()) {
 528                     // don't have connect permission to any local address
 529                     return null;
 530                 }
 531             }
 532         }
 533         for (InetAddress addr : addrs) {
 534             if (addr instanceof Inet4Address) {
 535                 return getMacAddr0(((Inet4Address)addr).getAddress(), name, index);
 536             }
 537         }
 538         return getMacAddr0(null, name, index);
 539     }
 540 
 541     /**
 542      * Returns the Maximum Transmission Unit (MTU) of this interface.
 543      *
 544      * @return the value of the MTU for that interface.
 545      * @exception       SocketException if an I/O error occurs.
 546      * @since 1.6
 547      */
 548     public int getMTU() throws SocketException {
 549         return getMTU0(name, index);
 550     }
 551 
 552     /**
 553      * Returns whether this interface is a virtual interface (also called
 554      * subinterface).
 555      * Virtual interfaces are, on some systems, interfaces created as a child
 556      * of a physical interface and given different settings (like address or
 557      * MTU). Usually the name of the interface will the name of the parent
 558      * followed by a colon (:) and a number identifying the child since there
 559      * can be several virtual interfaces attached to a single physical
 560      * interface.
 561      *
 562      * @return {@code true} if this interface is a virtual interface.
 563      * @since 1.6
 564      */
 565     public boolean isVirtual() {
 566         return virtual;
 567     }
 568 
 569     private static native boolean isUp0(String name, int ind) throws SocketException;
 570     private static native boolean isLoopback0(String name, int ind) throws SocketException;
 571     private static native boolean supportsMulticast0(String name, int ind) throws SocketException;
 572     private static native boolean isP2P0(String name, int ind) throws SocketException;
 573     private static native byte[] getMacAddr0(byte[] inAddr, String name, int ind) throws SocketException;
 574     private static native int getMTU0(String name, int ind) throws SocketException;
 575 
 576     /**
 577      * Compares this object against the specified object.
 578      * The result is {@code true} if and only if the argument is
 579      * not {@code null} and it represents the same NetworkInterface
 580      * as this object.
 581      * <p>
 582      * Two instances of {@code NetworkInterface} represent the same
 583      * NetworkInterface if both name and addrs are the same for both.
 584      *
 585      * @param   obj   the object to compare against.
 586      * @return  {@code true} if the objects are the same;
 587      *          {@code false} otherwise.
 588      * @see     java.net.InetAddress#getAddress()
 589      */
 590     public boolean equals(Object obj) {
 591         if (!(obj instanceof NetworkInterface)) {
 592             return false;
 593         }
 594         NetworkInterface that = (NetworkInterface)obj;
 595         if (this.name != null ) {
 596             if (!this.name.equals(that.name)) {
 597                 return false;
 598             }
 599         } else {
 600             if (that.name != null) {
 601                 return false;
 602             }
 603         }
 604 
 605         if (this.addrs == null) {
 606             return that.addrs == null;
 607         } else if (that.addrs == null) {
 608             return false;
 609         }
 610 
 611         /* Both addrs not null. Compare number of addresses */
 612 
 613         if (this.addrs.length != that.addrs.length) {
 614             return false;
 615         }
 616 
 617         InetAddress[] thatAddrs = that.addrs;
 618         int count = thatAddrs.length;
 619 
 620         for (int i=0; i<count; i++) {
 621             boolean found = false;
 622             for (int j=0; j<count; j++) {
 623                 if (addrs[i].equals(thatAddrs[j])) {
 624                     found = true;
 625                     break;
 626                 }
 627             }
 628             if (!found) {
 629                 return false;
 630             }
 631         }
 632         return true;
 633     }
 634 
 635     public int hashCode() {
 636         return name == null? 0: name.hashCode();
 637     }
 638 
 639     public String toString() {
 640         String result = "name:";
 641         result += name == null? "null": name;
 642         if (displayName != null) {
 643             result += " (" + displayName + ")";
 644         }
 645         return result;
 646     }
 647 
 648     private static native void init();
 649 
 650     /**
 651      * Returns the default network interface of this system
 652      *
 653      * @return the default interface
 654      */
 655     static NetworkInterface getDefault() {
 656         return defaultInterface;
 657     }
 658 }
--- EOF ---