libjava/classpath/java/net/NetworkInterface.java

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