gomp-20050608-branch/libjava/classpath/java/net/NetworkInterface.java

   1 /* NetworkInterface.java --
   2    Copyright (C) 2002, 2003, 2004, 2005  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 java.util.Collection;
  42 import java.util.Collections;
  43 import java.util.Enumeration;
  44 import java.util.HashMap;
  45 import java.util.Iterator;
  46 import java.util.Map;
  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 String name;
  62   private Vector inetAddresses;
  63
  64   NetworkInterface(String name, InetAddress address)
  65   {
  66     this.name = name;
  67     this.inetAddresses = new Vector(1, 1);
  68     this.inetAddresses.add(address);
  69   }
  70
  71   NetworkInterface(String name, InetAddress[] addresses)
  72   {
  73     this.name = name;
  74     this.inetAddresses = new Vector(addresses.length, 1);
  75
  76     for (int i = 0; i < addresses.length; i++)
  77       this.inetAddresses.add(addresses[i]);
  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 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 getInetAddresses()
 101   {
 102     SecurityManager s = System.getSecurityManager();
 103
 104     if (s == null)
 105       return inetAddresses.elements();
 106
 107     Vector tmpInetAddresses = new Vector(1, 1);
 108
 109     for (Enumeration addresses = inetAddresses.elements();
 110          addresses.hasMoreElements();)
 111       {
 112         InetAddress addr = (InetAddress) addresses.nextElement();
 113         try
 114           {
 115             s.checkConnect(addr.getHostAddress(), 58000);
 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 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     for (Enumeration e = getNetworkInterfaces(); e.hasMoreElements();)
 152       {
 153         NetworkInterface tmp = (NetworkInterface) e.nextElement();
 154
 155         if (name.equals(tmp.getName()))
 156           return tmp;
 157       }
 158
 159     // No interface with the given name found.
 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     for (Enumeration interfaces = getNetworkInterfaces();
 177          interfaces.hasMoreElements();)
 178       {
 179         NetworkInterface tmp = (NetworkInterface) interfaces.nextElement();
 180
 181         for (Enumeration addresses = tmp.inetAddresses.elements();
 182              addresses.hasMoreElements();)
 183           {
 184             if (addr.equals((InetAddress) addresses.nextElement()))
 185               return tmp;
 186           }
 187       }
 188
 189     throw new SocketException("no network interface is bound to such an IP address");
 190   }
 191
 192   static private Collection condense(Collection interfaces)
 193   {
 194     final Map condensed = new HashMap();
 195
 196     final Iterator interfs = interfaces.iterator();
 197     while (interfs.hasNext()) {
 198
 199       final NetworkInterface face = (NetworkInterface) interfs.next();
 200       final String name = face.getName();
 201
 202       if (condensed.containsKey(name))
 203         {
 204           final NetworkInterface conface = (NetworkInterface) condensed.get(name);
 205           if (!conface.inetAddresses.containsAll(face.inetAddresses))
 206             {
 207               final Iterator faceAddresses = face.inetAddresses.iterator();
 208               while (faceAddresses.hasNext())
 209                 {
 210                   final InetAddress faceAddress = (InetAddress) faceAddresses.next();
 211                   if (!conface.inetAddresses.contains(faceAddress))
 212                     {
 213                       conface.inetAddresses.add(faceAddress);
 214                     }
 215                 }
 216             }
 217         }
 218       else
 219         {
 220           condensed.put(name, face);
 221         }
 222     }
 223
 224     return condensed.values();
 225   }
 226
 227   /**
 228    * Return an <code>Enumeration</code> of all available network interfaces
 229    *
 230    * @return all interfaces
 231    *
 232    * @exception SocketException If an error occurs
 233    */
 234   public static Enumeration getNetworkInterfaces() throws SocketException
 235   {
 236     Vector networkInterfaces = VMNetworkInterface.getInterfaces();
 237
 238     if (networkInterfaces.isEmpty())
 239       return null;
 240
 241     Collection condensed = condense(networkInterfaces);
 242
 243     return Collections.enumeration(condensed);
 244   }
 245
 246   /**
 247    * Checks if the current instance is equal to obj
 248    *
 249    * @param obj The object to compare with
 250    *
 251    * @return <code>true</code> if equal, <code>false</code> otherwise
 252    */
 253   public boolean equals(Object obj)
 254   {
 255     if (! (obj instanceof NetworkInterface))
 256       return false;
 257
 258     NetworkInterface tmp = (NetworkInterface) obj;
 259
 260     return (name.equals(tmp.name) && inetAddresses.equals(tmp.inetAddresses));
 261   }
 262
 263   /**
 264    * Returns the hashcode of the current instance
 265    *
 266    * @return the hashcode
 267    */
 268   public int hashCode()
 269   {
 270     // FIXME: hash correctly
 271     return name.hashCode() + inetAddresses.hashCode();
 272   }
 273
 274   /**
 275    * Returns a string representation of the interface
 276    *
 277    * @return the string
 278    */
 279   public String toString()
 280   {
 281     // FIXME: check if this is correct
 282     String result;
 283     String separator = System.getProperty("line.separator");
 284
 285     result =
 286       "name: " + getDisplayName() + " (" + getName() + ") addresses:"
 287       + separator;
 288
 289     for (Enumeration e = inetAddresses.elements(); e.hasMoreElements();)
 290       {
 291         InetAddress address = (InetAddress) e.nextElement();
 292         result += address.toString() + ";" + separator;
 293       }
 294
 295     return result;
 296   }
 297 }