Source for java.net.NetworkInterface

 1:  /* NetworkInterface.java --
 2:  Copyright (C) 2002, 2003, 2004, 2005, 2006 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 java.util.Enumeration;
 44:  import java.util.Iterator;
 45:  import java.util.Vector;
 46: 
 47:  /**
 48:  * This class models a network interface on the host computer. A network
 49:  * interface contains a name (typically associated with a specific
 50:  * hardware adapter) and a list of addresses that are bound to it.
 51:  * For example, an ethernet interface may be named "eth0" and have the
 52:  * address 192.168.1.101 assigned to it.
 53:  *
 54:  * @author Michael Koch (konqueror@gmx.de)
 55:  * @since 1.4
 56:  */
 57:  public final class NetworkInterface
 58: {
 59:  private final VMNetworkInterface netif;
 60:  
 61:  private NetworkInterface(VMNetworkInterface netif)
 62:  {
 63:  this.netif = netif;
 64:  }
 65:  
 66:  /** Creates an NetworkInterface instance which
 67:  * represents any interface in the system. Its only
 68:  * address is <code>0.0.0.0/0.0.0.0</code>. This
 69:  * method is needed by {@link MulticastSocket#getNetworkInterface}
 70:  */
 71:  static NetworkInterface createAnyInterface()
 72:  {
 73:  return new NetworkInterface(new VMNetworkInterface());
 74:  }
 75:  
 76:  /**
 77:  * Returns the name of the network interface
 78:  *
 79:  * @return The name of the interface.
 80:  */
 81:  public String getName()
 82:  {
 83:  return netif.name;
 84:  }
 85: 
 86:  /**
 87:  * Returns all available addresses of the network interface
 88:  *
 89:  * If a @see SecurityManager is available all addresses are checked
 90:  * with @see SecurityManager::checkConnect() if they are available.
 91:  * Only <code>InetAddresses</code> are returned where the security manager
 92:  * doesn't throw an exception.
 93:  *
 94:  * @return An enumeration of all addresses.
 95:  */
 96:  public Enumeration<InetAddress> getInetAddresses()
 97:  {
 98:  SecurityManager s = System.getSecurityManager();
 99:  Vector<InetAddress> inetAddresses
 100:  = new Vector<InetAddress>(netif.addresses);
 101: 
 102:  if (s == null)
 103:  return inetAddresses.elements();
 104: 
 105:  Vector<InetAddress> tmpInetAddresses = new Vector<InetAddress>(1, 1);
 106: 
 107:  for (Enumeration<InetAddress> addresses = inetAddresses.elements();
 108:  addresses.hasMoreElements();)
 109:  {
 110:  InetAddress addr = addresses.nextElement();
 111:  try
 112:  {
 113:  s.checkConnect(addr.getHostAddress(), -1);
 114:  tmpInetAddresses.add(addr);
 115:  }
 116:  catch (SecurityException e)
 117:  {
 118:  // Ignore.
 119:  }
 120:  }
 121: 
 122:  return tmpInetAddresses.elements();
 123:  }
 124: 
 125:  /**
 126:  * Returns the display name of the interface
 127:  *
 128:  * @return The display name of the interface
 129:  */
 130:  public String getDisplayName()
 131:  {
 132:  return netif.name;
 133:  }
 134: 
 135:  /**
 136:  * Returns an network interface by name
 137:  *
 138:  * @param name The name of the interface to return
 139:  * 
 140:  * @return a <code>NetworkInterface</code> object representing the interface,
 141:  * or null if there is no interface with that name.
 142:  *
 143:  * @exception SocketException If an error occurs
 144:  * @exception NullPointerException If the specified name is null
 145:  */
 146:  public static NetworkInterface getByName(String name)
 147:  throws SocketException
 148:  {
 149:  if (name == null)
 150:  throw new NullPointerException();
 151:  VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces();
 152:  for (int i = 0; i < netifs.length; i++)
 153:  {
 154:  if (netifs[i].name.equals(name))
 155:  return new NetworkInterface(netifs[i]);
 156:  }
 157:  return null;
 158:  }
 159: 
 160:  /**
 161:  * Return a network interface by its address
 162:  *
 163:  * @param addr The address of the interface to return
 164:  *
 165:  * @return the interface, or <code>null</code> if none found
 166:  *
 167:  * @exception SocketException If an error occurs
 168:  * @exception NullPointerException If the specified addess is null
 169:  */
 170:  public static NetworkInterface getByInetAddress(InetAddress addr)
 171:  throws SocketException
 172:  {
 173:  if (addr == null)
 174:  throw new NullPointerException();
 175:  VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces();
 176:  for (int i = 0; i < netifs.length; i++)
 177:  {
 178:  if (netifs[i].addresses.contains(addr))
 179:  return new NetworkInterface(netifs[i]);
 180:  }
 181:  return null;
 182:  }
 183: 
 184:  /**
 185:  * Return an <code>Enumeration</code> of all available network interfaces
 186:  *
 187:  * @return all interfaces
 188:  * 
 189:  * @exception SocketException If an error occurs
 190:  */
 191:  public static Enumeration<NetworkInterface> getNetworkInterfaces()
 192:  throws SocketException
 193:  {
 194:  VMNetworkInterface[] netifs = VMNetworkInterface.getVMInterfaces();
 195:  Vector<NetworkInterface> networkInterfaces = 
 196:  new Vector<NetworkInterface>(netifs.length);
 197:  for (int i = 0; i < netifs.length; i++)
 198:  {
 199:  if (!netifs[i].addresses.isEmpty())
 200:  networkInterfaces.add(new NetworkInterface(netifs[i]));
 201:  }
 202:  return networkInterfaces.elements();
 203:  }
 204: 
 205:  /**
 206:  * Checks if the current instance is equal to obj
 207:  *
 208:  * @param obj The object to compare with
 209:  *
 210:  * @return <code>true</code> if equal, <code>false</code> otherwise
 211:  */
 212:  public boolean equals(Object obj)
 213:  {
 214:  if (! (obj instanceof NetworkInterface))
 215:  return false;
 216: 
 217:  NetworkInterface tmp = (NetworkInterface) obj;
 218:  
 219:  if (netif.name == null)
 220:  return tmp.netif.name == null;
 221: 
 222:  return (netif.name.equals(tmp.netif.name)
 223:  && (netif.addresses.equals(tmp.netif.addresses)));
 224:  }
 225: 
 226:  /**
 227:  * Returns the hashcode of the current instance
 228:  *
 229:  * @return the hashcode
 230:  */
 231:  public int hashCode()
 232:  {
 233:  // FIXME: hash correctly
 234:  int hc = netif.addresses.hashCode();
 235:  
 236:  if (netif.name != null)
 237:  hc += netif.name.hashCode();
 238:  
 239:  return hc;
 240:  }
 241: 
 242:  /**
 243:  * Returns a string representation of the interface
 244:  *
 245:  * @return the string
 246:  */
 247:  public String toString()
 248:  {
 249:  // FIXME: check if this is correct
 250:  StringBuffer result;
 251:  String separator = SystemProperties.getProperty("line.separator");
 252: 
 253:  result = new StringBuffer();
 254:  
 255:  result.append("name: ");
 256:  result.append(getDisplayName());
 257:  result.append(" (").append(getName()).append(") addresses:");
 258:  result.append(separator);
 259: 
 260:  for (Iterator it = netif.addresses.iterator(); it.hasNext(); )
 261:  {
 262:  InetAddress address = (InetAddress) it.next();
 263:  result.append(address.toString()).append(";").append(separator);
 264:  }
 265: 
 266:  return result.toString();
 267:  }
 268: }