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