GNU Classpath (0.98) | |
Frames | No Frames |
1: /* NetworkInterface.java -- 2: Copyright (C) 2002, 2003, 2004, 2005, 2006, 2008 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.net; 40: 41: import gnu.classpath.SystemProperties; 42: 43: import gnu.java.lang.CPStringBuilder; 44: 45: import java.util.Enumeration; 46: import java.util.Iterator; 47: import java.util.Vector; 48: 49: /** 50: * This class models a network interface on the host computer. A network 51: * interface contains a name (typically associated with a specific 52: * hardware adapter) and a list of addresses that are bound to it. 53: * For example, an ethernet interface may be named "eth0" and have the 54: * address 192.168.1.101 assigned to it. 55: * 56: * @author Michael Koch (konqueror@gmx.de) 57: * @since 1.4 58: */ 59: public final class NetworkInterface 60: { 61: private final VMNetworkInterface netif; 62: 63: private NetworkInterface(VMNetworkInterface netif) 64: { 65: this.netif = netif; 66: } 67: 68: /** Creates an NetworkInterface instance which 69: * represents any interface in the system. Its only 70: * address is <code>0.0.0.0/0.0.0.0</code>. This 71: * method is needed by {@link MulticastSocket#getNetworkInterface} 72: */ 73: static NetworkInterface createAnyInterface() 74: { 75: return new NetworkInterface(new VMNetworkInterface()); 76: } 77: 78: /** 79: * Returns the name of the network interface 80: * 81: * @return The name of the interface. 82: */ 83: public String getName() 84: { 85: return netif.name; 86: } 87: 88: /** 89: * Returns all available addresses of the network interface 90: * 91: * If a @see SecurityManager is available all addresses are checked 92: * with @see SecurityManager::checkConnect() if they are available. 93: * Only <code>InetAddresses</code> are returned where the security manager 94: * doesn't throw an exception. 95: * 96: * @return An enumeration of all addresses. 97: */ 98: public Enumeration<InetAddress> getInetAddresses() 99: { 100: SecurityManager s = System.getSecurityManager(); 101: Vector<InetAddress> inetAddresses 102: = new Vector<InetAddress>(netif.addresses); 103: 104: if (s == null) 105: return inetAddresses.elements(); 106: 107: Vector<InetAddress> tmpInetAddresses = new Vector<InetAddress>(1, 1); 108: 109: for (Enumeration<InetAddress> addresses = inetAddresses.elements(); 110: addresses.hasMoreElements();) 111: { 112: InetAddress addr = addresses.nextElement(); 113: try 114: { 115: s.checkConnect(addr.getHostAddress(), -1); 116: tmpInetAddresses.add(addr); 117: } 118: catch (SecurityException e) 119: { 120: // Ignore. 121: } 122: } 123: 124: return tmpInetAddresses.elements(); 125: } 126: 127: /** 128: * Returns the display name of the interface 129: * 130: * @return The display name of the interface 131: */ 132: public String getDisplayName() 133: { 134: return netif.name; 135: } 136: 137: /** 138: * Returns an network interface by name 139: * 140: * @param name The name of the interface to return 141: * 142: * @return a <code>NetworkInterface</code> object representing the interface, 143: * or null if there is no interface with that name. 144: * 145: * @exception SocketException If an error occurs 146: * @exception NullPointerException If the specified name is null 147: */ 148: public static NetworkInterface getByName(String name) 149: throws SocketException 150: { 151: if (name == null) 152: throw new NullPointerException(); 153: VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces(); 154: for (int i = 0; i < netifs.length; i++) 155: { 156: if (netifs[i].name.equals(name)) 157: return new NetworkInterface(netifs[i]); 158: } 159: return null; 160: } 161: 162: /** 163: * Return a network interface by its address 164: * 165: * @param addr The address of the interface to return 166: * 167: * @return the interface, or <code>null</code> if none found 168: * 169: * @exception SocketException If an error occurs 170: * @exception NullPointerException If the specified addess is null 171: */ 172: public static NetworkInterface getByInetAddress(InetAddress addr) 173: throws SocketException 174: { 175: if (addr == null) 176: throw new NullPointerException(); 177: VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces(); 178: for (int i = 0; i < netifs.length; i++) 179: { 180: if (netifs[i].addresses.contains(addr)) 181: return new NetworkInterface(netifs[i]); 182: } 183: return null; 184: } 185: 186: /** 187: * Return an <code>Enumeration</code> of all available network interfaces 188: * 189: * @return all interfaces 190: * 191: * @exception SocketException If an error occurs 192: */ 193: public static Enumeration<NetworkInterface> getNetworkInterfaces() 194: throws SocketException 195: { 196: VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces(); 197: Vector<NetworkInterface> networkInterfaces = 198: new Vector<NetworkInterface>(netifs.length); 199: for (int i = 0; i < netifs.length; i++) 200: { 201: if (!netifs[i].addresses.isEmpty()) 202: networkInterfaces.add(new NetworkInterface(netifs[i])); 203: } 204: return networkInterfaces.elements(); 205: } 206: 207: /** 208: * Checks if the current instance is equal to obj 209: * 210: * @param obj The object to compare with 211: * 212: * @return <code>true</code> if equal, <code>false</code> otherwise 213: */ 214: public boolean equals(Object obj) 215: { 216: if (! (obj instanceof NetworkInterface)) 217: return false; 218: 219: NetworkInterface tmp = (NetworkInterface) obj; 220: 221: if (netif.name == null) 222: return tmp.netif.name == null; 223: 224: return (netif.name.equals(tmp.netif.name) 225: && (netif.addresses.equals(tmp.netif.addresses))); 226: } 227: 228: /** 229: * Returns the hashcode of the current instance 230: * 231: * @return the hashcode 232: */ 233: public int hashCode() 234: { 235: // FIXME: hash correctly 236: int hc = netif.addresses.hashCode(); 237: 238: if (netif.name != null) 239: hc += netif.name.hashCode(); 240: 241: return hc; 242: } 243: 244: /** 245: * Returns a string representation of the interface 246: * 247: * @return the string 248: */ 249: public String toString() 250: { 251: // FIXME: check if this is correct 252: CPStringBuilder result; 253: String separator = SystemProperties.getProperty("line.separator"); 254: 255: result = new CPStringBuilder(); 256: 257: result.append("name: "); 258: result.append(getDisplayName()); 259: result.append(" (").append(getName()).append(") addresses:"); 260: result.append(separator); 261: 262: for (Iterator it = netif.addresses.iterator(); it.hasNext(); ) 263: { 264: InetAddress address = (InetAddress) it.next(); 265: result.append(address.toString()).append(";").append(separator); 266: } 267: 268: return result.toString(); 269: } 270: 271: /** 272: * Determines whether this interface is ready to transfer data. 273: * 274: * @return whether the interface is up 275: */ 276: public boolean isUp() 277: throws SocketException 278: { 279: return VMNetworkInterface.isUp(netif.name); 280: } 281: 282: /** 283: * Determines whether this interface does point to point 284: * transmission. 285: * 286: * @return whether the interface does point to point transmission 287: */ 288: public boolean isPointToPoint() 289: throws SocketException 290: { 291: return VMNetworkInterface.isPointToPoint(netif.name); 292: } 293: 294: /** 295: * Determines whether this interface is the loopback interface. 296: * 297: * @return whether the interface is the loopback interface 298: */ 299: public boolean isLoopback() 300: throws SocketException 301: { 302: return VMNetworkInterface.isLoopback(netif.name); 303: } 304: 305: /** 306: * Determines whether this interface supports multicast transmission. 307: * 308: * @return whether the interface supports multicast transmission. 309: */ 310: public boolean supportsMulticast() 311: throws SocketException 312: { 313: return VMNetworkInterface.supportsMulticast(netif.name); 314: } 315: 316: }
GNU Classpath (0.98) |