libjava/classpath/java/net/NetworkInterface.java

   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 }