libjava/java/net/NetworkInterface.java

   1 /* NetworkInterface.java
   2    Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 package java.net;
  39
  40 import gnu.classpath.Configuration;
  41 import java.util.Enumeration;
  42 import java.util.Vector;
  43
  44 /**
  45  * This class models a network interface on the host computer.  A network
  46  * interface contains a name (typically associated with a specific
  47  * hardware adapter) and a list of addresses that are bound to it.
  48  * For example, an ethernet interface may be named "eth0" and have the
  49  * address 192.168.1.101 assigned to it.
  50  *
  51  * @author Michael Koch <konqueror@gmx.de>
  52  * @since 1.4
  53  */
  54 public final class NetworkInterface
  55 {
  56   static
  57   {
  58     if (Configuration.INIT_LOAD_LIBRARY)
  59       {
  60         System.loadLibrary ("javanet");
  61       }
  62   }
  63
  64   private String name;
  65
  66   private Vector inetAddresses;
  67
  68   private NetworkInterface (String name, InetAddress address)
  69   {
  70     this.name = name;
  71     this.inetAddresses = new Vector (1, 1);
  72     this.inetAddresses.add (address);
  73   }
  74
  75   private native static Vector getRealNetworkInterfaces ()
  76     throws SocketException;
  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 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 getInetAddresses ()
  99   {
 100     SecurityManager s = System.getSecurityManager ();
 101
 102     if (s == null)
 103       return inetAddresses.elements ();
 104
 105     Vector tmpInetAddresses = new Vector (1, 1);
 106
 107     for (Enumeration addresses = inetAddresses.elements ();
 108          addresses.hasMoreElements (); )
 109       {
 110         InetAddress addr = (InetAddress) addresses.nextElement ();
 111         try
 112           {
 113             s.checkConnect (addr.getHostAddress (), 58000);
 114             tmpInetAddresses.add (addr);
 115           }
 116         catch (SecurityException e)
 117           {
 118           }
 119     }
 120
 121     return tmpInetAddresses.elements ();
 122   }
 123
 124   /**
 125    *  Returns the display name of the interface
 126    *
 127    *  @return The display name of the interface
 128    */
 129   public String getDisplayName ()
 130   {
 131     return name;
 132   }
 133
 134   /**
 135    *  Returns an network interface by name
 136    *
 137    *  @param name The name of the interface to return
 138    *
 139    *  @exception SocketException If an error occurs
 140    *  @exception NullPointerException If the specified name is null
 141    */
 142   public static NetworkInterface getByName (String name)
 143     throws SocketException
 144   {
 145     Vector networkInterfaces = getRealNetworkInterfaces ();
 146
 147     for (Enumeration e = networkInterfaces.elements ();
 148          e.hasMoreElements (); )
 149       {
 150         NetworkInterface tmp = (NetworkInterface) e.nextElement ();
 151
 152         if (name.equals (tmp.getName ()))
 153           return tmp;
 154       }
 155
 156     throw new SocketException ("no network interface with this name exists");
 157   }
 158
 159   /**
 160    *  Return a network interface by its address
 161    *
 162    *  @param addr The address of the interface to return
 163    *
 164    *  @exception SocketException If an error occurs
 165    *  @exception NullPointerException If the specified addess is null
 166    */
 167   public static NetworkInterface getByInetAddress (InetAddress addr)
 168     throws SocketException
 169   {
 170     Vector networkInterfaces = getRealNetworkInterfaces ();
 171
 172     for (Enumeration interfaces = networkInterfaces.elements ();
 173          interfaces.hasMoreElements (); )
 174       {
 175         NetworkInterface tmp = (NetworkInterface) interfaces.nextElement ();
 176
 177         for (Enumeration addresses = tmp.inetAddresses.elements ();
 178              addresses.hasMoreElements (); )
 179           {
 180             if (addr.equals ((InetAddress) addresses.nextElement ()))
 181               return tmp;
 182           }
 183       }
 184
 185     throw new SocketException (
 186       "no network interface is bound to such an IP address");
 187   }
 188
 189   /**
 190    *  Return an <code>Enumeration</code> of all available network interfaces
 191    *
 192    *  @exception SocketException If an error occurs
 193    */
 194   public static Enumeration getNetworkInterfaces ()
 195     throws SocketException
 196   {
 197     Vector networkInterfaces = getRealNetworkInterfaces();
 198
 199     if (networkInterfaces.isEmpty())
 200       return null;
 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   public boolean equals (Object obj)
 211   {
 212     if (!(obj instanceof NetworkInterface))
 213       return false;
 214
 215     NetworkInterface tmp = (NetworkInterface) obj;
 216
 217     return (name.equals (tmp.name)
 218             && inetAddresses.equals (tmp.inetAddresses));
 219   }
 220
 221   /**
 222    *  Returns the hashcode of the current instance
 223    */
 224   public int hashCode ()
 225   {
 226     // FIXME: hash correctly
 227     return name.hashCode () + inetAddresses.hashCode ();
 228   }
 229
 230   /**
 231    *  Returns a string representation of the interface
 232    */
 233   public String toString ()
 234   {
 235     // FIXME: check if this is correct
 236     String result;
 237     String separator = System.getProperty ("line.separator");
 238
 239     result = "name: " + getDisplayName () + " (" + getName () +
 240              ") addresses:" + separator;
 241
 242     for (Enumeration e = inetAddresses.elements ();
 243          e.hasMoreElements (); )
 244       {
 245         InetAddress address = (InetAddress) e.nextElement ();
 246         result += address.toString () + ";" + separator;
 247       }
 248
 249     return result;
 250   }
 251 } // class NetworkInterface