Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2919] trunk/core/src/classpath/gnu/gnu/java

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 2919
          http://jnode.svn.sourceforge.net/jnode/?rev=2919&view=rev
Author:   hagar-wize
Date:     2006-12-14 02:17:15 -0800 (Thu, 14 Dec 2006)

Log Message:
-----------
Classpath patches

Modified Paths:
--------------
    trunk/core/src/classpath/gnu/gnu/java/net/PlainDatagramSocketImpl.java
    trunk/core/src/classpath/gnu/gnu/java/net/PlainSocketImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/charset/ISO_8859_1.java
    trunk/core/src/classpath/gnu/gnu/java/nio/charset/US_ASCII.java
    trunk/core/src/classpath/gnu/gnu/java/nio/charset/iconv/IconvEncoder.java

Modified: trunk/core/src/classpath/gnu/gnu/java/net/PlainDatagramSocketImpl.java
===================================================================

--- trunk/core/src/classpath/gnu/gnu/java/net/PlainDatagramSocketImpl.java	2006-12-14 10:15:31 UTC (rev 2918)
+++ trunk/core/src/classpath/gnu/gnu/java/net/PlainDatagramSocketImpl.java	2006-12-14 10:17:15 UTC (rev 2919)
@@ -1,5 +1,5 @@
 /* PlainDatagramSocketImpl.java -- Default DatagramSocket implementation
-   Copyright (C) 1998, 1999, 2001, 2003, 2004, 2005  Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -38,7 +38,10 @@
 
 package gnu.java.net;
 
+import gnu.java.nio.VMChannel;
+
 import java.io.IOException;
+import java.io.InterruptedIOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocketImpl;
 import java.net.InetAddress;
@@ -46,8 +49,8 @@
 import java.net.NetworkInterface;
 import java.net.SocketAddress;
 import java.net.SocketException;
-import java.net.SocketOptions;
-import gnu.classpath.Configuration;
+import java.net.SocketTimeoutException;
+import java.nio.ByteBuffer;
 
 /**
  * Written using on-line Java Platform 1.2 API Specification, as well
@@ -65,17 +68,12 @@
  */
 public final class PlainDatagramSocketImpl extends DatagramSocketImpl
 {
-   // @vm-specific removed System.loadLibrary
-   
+  private final VMChannel channel;
+  
   /**
-   * Option id for the IP_TTL (time to live) value.
+   * The platform-specific socket implementation.
    */
-  private static final int IP_TTL = 0x1E61; // 7777
-
-  /**
-   * This is the actual underlying file descriptor
-   */
-  int native_fd = -1;
+  private final VMPlainSocketImpl impl;
   
   /**
    * Lock object to serialize threads wanting to receive 
@@ -90,24 +88,26 @@
   /**
    * Default do nothing constructor
    */
-  public PlainDatagramSocketImpl()
+  public PlainDatagramSocketImpl() throws IOException
   {
+    channel = new VMChannel();
+    impl = new VMPlainSocketImpl(channel);
   }
 
-  protected void finalize() throws Throwable
+  /*protected void finalize() throws Throwable
   {
     synchronized (this)
       {
-	if (native_fd != -1)
+        if (channel.getState().isValid())
 	  close();
       }
     super.finalize();
-  }
+  }*/
 
-  public int getNativeFD()
+  /*public int getNativeFD()
   {
     return native_fd;
-  }
+  }*/
 
   /**
    * Binds this socket to a particular port and interface
@@ -120,9 +120,20 @@
   protected synchronized void bind(int port, InetAddress addr)
     throws SocketException
   {
-      // @vm-specific no natives
-      //TODO implement me
-      throw new SocketException("Not implemented");
+    try
+      {
+        impl.bind(new InetSocketAddress(addr, port));
+      }
+    catch (SocketException se)
+      {
+        throw se;
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
   }
 
   /**
@@ -130,13 +141,58 @@
    *
    * @exception SocketException If an error occurs
    */
-  protected synchronized void create() throws SocketException {
-      // @vm-specific no natives
-      //TODO implement me
-      throw new SocketException("Not implemented");
+  protected synchronized void create() throws SocketException
+  {
+    try
+      {
+        channel.initSocket(false);
+      }
+    catch (SocketException se)
+      {
+        throw se;
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
   }
 
   /**
+   * Connects to the remote address and port specified as arguments.
+   *
+   * @param addr The remote address to connect to
+   * @param port The remote port to connect to
+   *
+   * @exception SocketException If an error occurs
+   */
+  protected void connect(InetAddress addr, int port) throws SocketException
+  {
+    channel.connect(new InetSocketAddress(addr, port), 0);
+  }
+
+  /**
+   * Disconnects the socket.
+   *
+   * @since 1.4
+   */
+  protected void disconnect()
+  {
+    synchronized (this)
+      {
+        try
+          {
+            if (channel.getState().isValid())
+              channel.disconnect();
+          }
+        catch (IOException ioe)
+          {
+          }
+      }
+  }
+
+  /**
    * Sets the Time to Live value for the socket
    *
    * @param ttl The new TTL value
@@ -145,7 +201,7 @@
    */
   protected synchronized void setTimeToLive(int ttl) throws IOException
   {
-    setOption(IP_TTL, new Integer(ttl));
+    impl.setTimeToLive(ttl);
   }
 
   /**
@@ -157,48 +213,60 @@
    */
   protected synchronized int getTimeToLive() throws IOException
   {
-    Object obj = getOption(IP_TTL);
+    return impl.getTimeToLive();
+  }
 
-    if (! (obj instanceof Integer))
-      throw new IOException("Internal Error");
+  protected int getLocalPort()
+  {
+    if (channel == null)
+      return -1;
 
-    return ((Integer) obj).intValue();
+    try
+      {
+        InetSocketAddress local = channel.getLocalAddress();
+        if (local == null)
+          return -1;
+        return local.getPort();
+      }
+    catch (IOException ioe)
+      {
+        return -1;
+      }
   }
 
   /**
    * Sends a packet of data to a remote host
    *
-   * @param addr The address to send to
-   * @param port The port to send to 
-   * @param buf The buffer to send
-   * @param offset The offset of the data in the buffer to send
-   * @param len The length of the data to send
-   *
-   * @exception IOException If an error occurs
-   */
-  private void sendto (InetAddress addr, int port,
-                              byte[] buf, int offset, int len)
-    throws IOException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
-  }
-
-  /**
-   * Sends a packet of data to a remote host
-   *
    * @param packet The packet to send
    *
    * @exception IOException If an error occurs
    */
   protected void send(DatagramPacket packet) throws IOException
   {
-    synchronized(SEND_LOCK)
+    synchronized (SEND_LOCK)
       {
-      sendto(packet.getAddress(), packet.getPort(), packet.getData(), 
-             packet.getOffset(), packet.getLength());
+        ByteBuffer buf = ByteBuffer.wrap(packet.getData(),
+                                         packet.getOffset(),
+                                         packet.getLength());
+        InetAddress remote = packet.getAddress();
+        int port = packet.getPort();
+        if (remote == null)
+          throw new NullPointerException();
+        if (port <= 0)
+          throw new SocketException("invalid port " + port);
+        while (true)
+          {
+            try
+              {
+                channel.send(buf, new InetSocketAddress(remote, port));
+                break;
+              }
+            catch (InterruptedIOException ioe)
+              {
+                // Ignore; interrupted system call.
+              }
+          }
       }
-    
   }
 
   /**
@@ -211,63 +279,123 @@
   protected void receive(DatagramPacket packet)
     throws IOException
   {
-      synchronized(RECEIVE_LOCK)
-        {
-        receive0(packet);		
-        }
+    synchronized(RECEIVE_LOCK)
+      {
+        ByteBuffer buf = ByteBuffer.wrap(packet.getData(),
+                                         packet.getOffset(),
+                                         packet.getLength());
+        SocketAddress addr = null;
+        while (true)
+          {
+            try
+              {
+                addr = channel.receive(buf);
+                break;
+              }
+            catch (SocketTimeoutException ste)
+              {
+                throw ste;
+              }
+            catch (InterruptedIOException iioe)
+              {
+                // Ignore. Loop.
+              }
+          }
+        if (addr != null)
+          packet.setSocketAddress(addr);
+        packet.setLength(buf.position() - packet.getOffset());
+      }
   }
 
-  /**
-   * Native call to receive a UDP packet from the network
-   * 
-   * @param packet The packet to fill in with the data received
-   *
-   * @exception IOException IOException If an error occurs
-   */
-  private void receive0(DatagramPacket packet) throws IOException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
-  }
 
   /**
    * Sets the value of an option on the socket
    *
-   * @param option_id The identifier of the option to set
-   * @param val The value of the option to set
+   * @param optionId The identifier of the option to set
+   * @param value The value of the option to set
    *
    * @exception SocketException If an error occurs
    */
-  public synchronized void setOption(int option_id, Object val)
-    throws SocketException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
+  public synchronized void setOption(int optionId, Object value)
+    throws SocketException
+  {
+    switch (optionId)
+      {
+        case IP_MULTICAST_IF:
+        case IP_MULTICAST_IF2:
+          impl.setMulticastInterface(optionId, (InetAddress) value);
+          break;
+
+        case IP_MULTICAST_LOOP:
+        case SO_BROADCAST:
+        case SO_KEEPALIVE:
+        case SO_OOBINLINE:
+        case TCP_NODELAY:
+        case IP_TOS:
+        case SO_LINGER:
+        case SO_RCVBUF:
+        case SO_SNDBUF:
+        case SO_TIMEOUT:
+        case SO_REUSEADDR:
+          impl.setOption(optionId, value);
+          return;
+
+      default:
+        throw new SocketException("cannot set option " + optionId);
+      }
   }
 
   /**
    * Retrieves the value of an option on the socket
    *
-   * @param option_id The identifier of the option to retrieve
+   * @param optionId The identifier of the option to retrieve
    *
    * @return The value of the option
    *
    * @exception SocketException If an error occurs
    */
-  public synchronized Object getOption(int option_id)
-    throws SocketException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
+  public synchronized Object getOption(int optionId)
+    throws SocketException
+  {
+    if (optionId == SO_BINDADDR)
+      {
+        try
+          {
+            InetSocketAddress local = channel.getLocalAddress();
+            if (local == null)
+              return null;
+            return local.getAddress();
+          }
+        catch (SocketException se)
+          {
+            throw se;
+          }
+        catch (IOException ioe)
+          {
+            SocketException se = new SocketException();
+            se.initCause(ioe);
+            throw se;
+          }
+      }
+    if (optionId == IP_MULTICAST_IF || optionId == IP_MULTICAST_IF2)
+      return impl.getMulticastInterface(optionId);
+
+    return impl.getOption(optionId);
   }
 
   /**
    * Closes the socket
    */
-  protected synchronized void close() {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new RuntimeException("Not implemented");
+  protected synchronized void close()
+  {
+    try
+      {
+        if (channel.getState().isValid())
+          channel.close();
+      }
+    catch (IOException ioe)
+      {
+      }
   }
 
   /**
@@ -305,9 +433,9 @@
    *
    * @exception IOException If an error occurs
    */
-  protected synchronized void join(InetAddress addr) throws IOException {
-      // @vm-specific no natives
-      throw new SocketException("Not implemented");
+  protected synchronized void join(InetAddress addr) throws IOException
+  {
+    impl.join(addr);
   }
 
   /**
@@ -317,10 +445,9 @@
    *
    * @exception IOException If an error occurs
    */
-  protected synchronized void leave(InetAddress addr) throws IOException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
+  protected synchronized void leave(InetAddress addr) throws IOException
+  {
+    impl.leave(addr);
   }
 
   /**
@@ -338,14 +465,22 @@
   }
 
   public void joinGroup(SocketAddress address, NetworkInterface netIf)
+    throws IOException
   {
-    throw new InternalError
-      ("PlainDatagramSocketImpl::joinGroup is not implemented");
+    if (address == null)
+      throw new NullPointerException();
+    if (!(address instanceof InetSocketAddress))
+      throw new SocketException("unknown address type");
+    impl.joinGroup((InetSocketAddress) address, netIf);
   }
 
   public void leaveGroup(SocketAddress address, NetworkInterface netIf)
+    throws IOException
   {
-    throw new InternalError
-      ("PlainDatagramSocketImpl::leaveGroup is not implemented");
+    if (address == null)
+      throw new NullPointerException();
+    if (!(address instanceof InetSocketAddress))
+      throw new SocketException("unknown address type");
+    impl.leaveGroup((InetSocketAddress) address, netIf);
   }
 }

Modified: trunk/core/src/classpath/gnu/gnu/java/net/PlainSocketImpl.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/net/PlainSocketImpl.java	2006-12-14 10:15:31 UTC (rev 2918)
+++ trunk/core/src/classpath/gnu/gnu/java/net/PlainSocketImpl.java	2006-12-14 10:17:15 UTC (rev 2919)
@@ -39,16 +39,20 @@
 
 package gnu.java.net;
 
+import gnu.java.nio.SocketChannelImpl;
+import gnu.java.nio.VMChannel;
+
 import java.io.InputStream;
 import java.io.IOException;
+import java.io.InterruptedIOException;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.SocketException;
 import java.net.SocketImpl;
-import java.net.SocketOptions;
-import gnu.classpath.Configuration;
+import java.net.SocketTimeoutException;
+import java.nio.ByteBuffer;
 
 /**
  * Written using on-line Java Platform 1.2 API Specification, as well
@@ -66,25 +70,13 @@
  * @author Nic Ferrier (nfe...@ta...)
  * @author Aaron M. Renn (ar...@ur...)
  */
-public final class PlainSocketImpl extends SocketImpl
+public class PlainSocketImpl extends SocketImpl
 {
-  // Static initializer to load native library.
-  static
-    {
-      if (Configuration.INIT_LOAD_LIBRARY)
-        {
-          System.loadLibrary("javanet");
-        }
-    }
 
   /**
-   * The OS file handle representing the socket.
-   * This is used for reads and writes to/from the socket and
-   * to close it.
-   *
-   * When the socket is closed this is reset to -1.
+   * The underlying plain socket VM implementation.
    */
-  int native_fd = -1;
+  protected VMPlainSocketImpl impl;
 
   /**
    * A cached copy of the in stream for reading from the socket.
@@ -101,8 +93,14 @@
    * is being invoked on this socket.
    */
   private boolean inChannelOperation;
-
+  
   /**
+   * The socket channel we use for IO operation. Package-private for
+   * use by inner classes.
+   */
+  SocketChannelImpl channel;
+  
+  /**
    * Indicates whether we should ignore whether any associated
    * channel is set to non-blocking mode. Certain operations
    * throw an <code>IllegalBlockingModeException</code> if the
@@ -124,48 +122,44 @@
   }
  
   /**
-   * Default do nothing constructor
+   * Default do nothing constructor.
    */
   public PlainSocketImpl()
   {
+    this.impl = new VMPlainSocketImpl();
   }
-  
-  protected void finalize() throws Throwable
-  {
-    synchronized (this)
-      {
-	if (native_fd != -1)
-	  try
-	    {
-	      close();
-	    }
-	  catch (IOException ex)
-	    {
-	    }
-      }
-    super.finalize();
-  }
 
-  public int getNativeFD()
-  {
-    return native_fd;
-  }
-
   /**
    * Sets the specified option on a socket to the passed in object.  For
    * options that take an integer argument, the passed in object is an
    * Integer.  The option_id parameter is one of the defined constants in
    * this interface.
    *
-   * @param option_id The identifier of the option
-   * @param val The value to set the option to
+   * @param optionId The identifier of the option
+   * @param value The value to set the option to
    *
-   * @exception SocketException If an error occurs
+   * @throws SocketException if an error occurs
    */
-  public void setOption(int optID, Object value) throws SocketException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
+  public void setOption(int optionId, Object value) throws SocketException
+  {
+    switch (optionId)
+      {
+        case SO_LINGER:
+        case IP_MULTICAST_LOOP:
+        case SO_BROADCAST:
+        case SO_KEEPALIVE:
+        case SO_OOBINLINE:
+        case TCP_NODELAY:          
+        case IP_TOS:
+        case SO_RCVBUF:
+        case SO_SNDBUF:
+        case SO_TIMEOUT:
+        case SO_REUSEADDR:
+          impl.setOption(optionId, value);
+          return;
+        default:
+          throw new SocketException("Unrecognized TCP option: " + optionId);
+      }
   }
 
   /**
@@ -173,133 +167,144 @@
    * will be an Integer for options that have integer values.  The option_id
    * is one of the defined constants in this interface.
    *
-   * @param option_id The option identifier
+   * @param optionId the option identifier
    *
-   * @return The current value of the option
+   * @return the current value of the option
    *
-   * @exception SocketException If an error occurs
+   * @throws SocketException if an error occurs
    */
-  public Object getOption(int optID) throws SocketException {
-      // @vm-specific no natives
-      //TODO implement me      
-      throw new SocketException("Not implemented");
+  public Object getOption(int optionId) throws SocketException
+  {
+    if (optionId == SO_BINDADDR)
+      {
+        try
+          {
+            return channel.getVMChannel().getLocalAddress().getAddress();
+          }
+        catch (IOException ioe)
+          {
+            SocketException se = new SocketException();
+            se.initCause(ioe);
+            throw se;
+          }
+      }
+    
+    // This filters options which are invalid for TCP.
+    switch (optionId)
+    {
+      case SO_LINGER:
+      case IP_MULTICAST_LOOP:
+      case SO_BROADCAST:
+      case SO_KEEPALIVE:
+      case SO_OOBINLINE:
+      case TCP_NODELAY:          
+      case IP_TOS:
+      case SO_RCVBUF:
+      case SO_SNDBUF:
+      case SO_TIMEOUT:
+      case SO_REUSEADDR:
+        return impl.getOption(optionId);
+      default:
+        throw new SocketException("Unrecognized TCP option: " + optionId);
+    }
+    
   }
 
-  /**
-   * Flushes the input stream and closes it. If you read from the input stream
-   * after calling this method a <code>IOException</code> will be thrown.
-   * 
-   * @throws IOException if an error occurs
-   */
-  public void shutdownInput()
+  public void shutdownInput() throws IOException
   {
-      // @vm-specific no natives
-      //TODO implement me        
-    throw new InternalError ("PlainSocketImpl::shutdownInput not implemented");
+    impl.shutdownInput();
   }
 
-  /**
-   * Flushes the output stream and closes it. If you write to the output stream
-   * after calling this method a <code>IOException</code> will be thrown.
-   * 
-   * @throws IOException if an error occurs
-   */
   public void shutdownOutput() throws IOException
   {
-      // @vm-specific no natives
-      //TODO implement me        
-    throw new InternalError ("PlainSocketImpl::shutdownOutput not implemented");
+    impl.shutdownOutput();
   }
 
   /**
    * Creates a new socket that is not bound to any local address/port and
-   * is not connected to any remote address/port.  This will be created as
-   * a stream socket if the stream parameter is true, or a datagram socket
-   * if the stream parameter is false.
+   * is not connected to any remote address/port.  The stream parameter will be
+   * ignored since PlainSocketImpl always is a stream socket. Datagram sockets
+   * are handled by PlainDatagramSocketImpl.
    *
-   * @param stream true for a stream socket, false for a datagram socket
+   * @param stream <code>true</code> for stream sockets, <code>false</code> for
+   *        datagram sockets
    */
-  protected synchronized void create(boolean stream) throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
+  protected synchronized void create(boolean stream) throws IOException
+  {
+    channel = new SocketChannelImpl(false);
+    VMChannel vmchannel = channel.getVMChannel();
+    vmchannel.initSocket(stream);
+    channel.configureBlocking(true);
+    impl.getState().setChannelFD(vmchannel.getState());
   }
 
   /**
    * Connects to the remote hostname and port specified as arguments.
    *
-   * @param hostname The remote hostname to connect to
-   * @param port The remote port to connect to
+   * @param hostname the remote hostname to connect to
+   * @param port the remote port to connect to
    *
-   * @exception IOException If an error occurs
+   * @throws IOException If an error occurs
    */
-  protected synchronized void connect(String host, int port) throws IOException
+  protected synchronized void connect(String hostname, int port)
+    throws IOException
   {
-    connect(InetAddress.getByName(host), port);
+    connect(InetAddress.getByName(hostname), port);
   }
 
   /**
    * Connects to the remote address and port specified as arguments.
    *
-   * @param addr The remote address to connect to
-   * @param port The remote port to connect to
+   * @param addr the remote address to connect to
+   * @param port the remote port to connect to
    *
-   * @exception IOException If an error occurs
+   * @throws IOException If an error occurs
    */
-  protected void connect(InetAddress addr, int port) throws IOException {
-      // @vm-specific no natives
-      //TODO implement me                  
-      throw new SocketException("Not implemented");
+  protected void connect(InetAddress addr, int port) throws IOException
+  {
+    connect(new InetSocketAddress(addr, port), 0);
   }
 
   /**
    * Connects to the remote socket address with a specified timeout.
    *
-   * @param timeout The timeout to use for this connect, 0 means infinite.
+   * @param address the remote address to connect to
+   * @param timeout the timeout to use for this connect, 0 means infinite.
    *
-   * @exception IOException If an error occurs
+   * @throws IOException If an error occurs
    */
-  protected synchronized void connect(SocketAddress address, int timeout) throws IOException
+  protected synchronized void connect(SocketAddress address, int timeout)
+    throws IOException
   {
-    InetSocketAddress sockAddr = (InetSocketAddress) address;
-    InetAddress addr = sockAddr.getAddress();
-
-    if (addr == null)
-      throw new IllegalArgumentException("address is unresolved: " + sockAddr);
-
-    int port = sockAddr.getPort();
+    if (channel == null)
+      create(true);
+    boolean connected = channel.connect(address, timeout);
+    if (!connected)
+      throw new SocketTimeoutException("connect timed out");
     
-    if (timeout < 0)
-      throw new IllegalArgumentException("negative timeout");
-
-    Object oldTimeoutObj = null;
-    
-    try
-      {
- 	oldTimeoutObj = this.getOption (SocketOptions.SO_TIMEOUT);
- 	this.setOption (SocketOptions.SO_TIMEOUT, new Integer (timeout));
- 	connect (addr, port);
-      }
-    finally
-      {
-	if (oldTimeoutObj != null)
-	  this.setOption (SocketOptions.SO_TIMEOUT, oldTimeoutObj);
-      }
+    // Using the given SocketAddress is important to preserve
+    // hostnames given by the caller.
+    InetSocketAddress addr = (InetSocketAddress) address; 
+    this.address = addr.getAddress();
+    this.port = addr.getPort();
   }
 
   /**
    * Binds to the specified port on the specified addr.  Note that this addr
    * must represent a local IP address.  **** How bind to INADDR_ANY? ****
    *
-   * @param addr The address to bind to
-   * @param port The port number to bind to
+   * @param addr the address to bind to
+   * @param port the port number to bind to
    *
-   * @exception IOException If an error occurs
+   * @throws IOException if an error occurs
    */
   protected synchronized void bind(InetAddress addr, int port)
-    throws IOException {
-      // @vm-specific no natives
-      throw new SocketException("Not implemented");
+    throws IOException
+  {
+    if (channel == null)
+      create(true);
+    impl.bind(new InetSocketAddress(addr, port));
+    localport = channel.getVMChannel().getLocalAddress().getPort();
   }
 
   /**
@@ -310,13 +315,12 @@
    *
    * @param queuelen The length of the pending connection queue
    * 
-   * @exception IOException If an error occurs
+   * @throws IOException If an error occurs
    */
   protected synchronized void listen(int queuelen)
-    throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
+    throws IOException
+  {
+    impl.listen(queuelen);
   }
 
   /**
@@ -326,78 +330,64 @@
    * @param impl The SocketImpl object to accept this connection.
    */
   protected synchronized void accept(SocketImpl impl)
-    throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
+    throws IOException
+  {
+    if (channel == null)
+        create(true);
+    if (!(impl instanceof PlainSocketImpl))
+      throw new IOException("incompatible SocketImpl: "
+                            + impl.getClass().getName());
+    PlainSocketImpl that = (PlainSocketImpl) impl;
+    VMChannel c = channel.getVMChannel().accept();
+    that.impl.getState().setChannelFD(c.getState());
+    that.channel = new SocketChannelImpl(c);
+    that.setOption(SO_REUSEADDR, Boolean.TRUE);
+    // Reset the inherited timeout.
+    that.setOption(SO_TIMEOUT, Integer.valueOf(0));
+
   }
 
   /**
    * Returns the number of bytes that the caller can read from this socket
    * without blocking. 
    *
-   * @return The number of readable bytes before blocking
+   * @return the number of readable bytes before blocking
    *
-   * @exception IOException If an error occurs
+   * @throws IOException if an error occurs
    */
-  protected int available() throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
+  protected int available() throws IOException
+  {
+    if (channel == null)
+      throw new SocketException("not connected");
+    return channel.getVMChannel().available();
   }
 
   /**
    * Closes the socket.  This will cause any InputStream or OutputStream
    * objects for this Socket to be closed as well.
+   *
    * <p>
    * Note that if the SO_LINGER option is set on this socket, then the
    * operation could block.
+   * </p>
    *
-   * @exception IOException If an error occurs
+   * @throws IOException if an error occurs
    */
-  protected void close() throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
+  protected void close() throws IOException
+  {
+    if (impl.getState().isValid())
+      impl.close();
+    
+    address = null;
+    port = -1;
   }
 
-  public void sendUrgentData(int data)
+  public void sendUrgentData(int data) throws IOException
   {
-    throw new InternalError ("PlainSocketImpl::sendUrgentData not implemented");
+    impl.sendUrgentData(data);
   }
 
   /**
-   * Internal method used by SocketInputStream for reading data from
-   * the connection.  Reads up to len bytes of data into the buffer
-   * buf starting at offset bytes into the buffer.
-   *
-   * @return The actual number of bytes read or -1 if end of stream.
-   *
-   * @exception IOException If an error occurs
-   */
-  protected int read(byte[] buf, int offset, int len)
-    throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
-
-  }
-
-  /**
-   * Internal method used by SocketOuputStream for writing data to
-   * the connection.  Writes up to len bytes of data from the buffer
-   * buf starting at offset bytes into the buffer.
-   *
-   * @exception IOException If an error occurs
-   */
-  protected void write(byte[] buf, int offset, int len)
-    throws IOException {
-      // @vm-specific no natives
-      //TODO implement me            
-      throw new SocketException("Not implemented");
-  }
-
-  /**
    * Returns an InputStream object for reading from this socket.  This will
    * be an instance of SocketInputStream.
    *
@@ -409,7 +399,7 @@
   {
     if (in == null)
       in = new SocketInputStream();
-    
+
     return in;
   }
 
@@ -425,15 +415,104 @@
   {
     if (out == null)
       out = new SocketOutputStream();
-    
+
     return out;
   }
+  
+  public VMChannel getVMChannel()
+  {
+    if (channel == null)
+      return null;
+    return channel.getVMChannel();
+  }
 
+  /* (non-Javadoc)
+   * @see java.net.SocketImpl#getInetAddress()
+   */
+  protected InetAddress getInetAddress()
+  {
+    if (channel == null)
+      return null;
+    
+    try
+      {
+        InetSocketAddress remote = channel.getVMChannel().getPeerAddress();
+   ...
 
[truncated message content]

Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2919] trunk/core/src/classpath/gnu/gnu/java

jnode-svn-commits