Source for java.net.NetworkInterface

   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: }