jnode-svn-commits Mailing List for JNode: new Java Operating System (Page 119)

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();
+        if (remote == null)
+          return null;
+        // To mimic behavior of the RI the InetAddress instance which was
+        // used to establish the connection is returned instead of one that
+        // was created by the native layer (this preserves exact hostnames).
+        if (address != null)
+          return address;
+        
+        return remote.getAddress();
+      }
+    catch (IOException ioe)
+      {
+        return null;
+      }
+  }
+
+  /* (non-Javadoc)
+   * @see java.net.SocketImpl#getLocalPort()
+   */
+  protected int getLocalPort()
+  {
+    if (channel == null)
+      return -1;
+    try
+      {
+        InetSocketAddress local = channel.getVMChannel().getLocalAddress();
+        if (local == null)
+          return -1;
+        return local.getPort();
+      }
+    catch (IOException ioe)
+      {
+        return -1;
+      }
+  }
+  
+  public InetSocketAddress getLocalAddress()
+  {
+    if (channel == null)
+      return null;
+    try
+      {
+        return channel.getVMChannel().getLocalAddress();
+      }
+    catch (IOException ioe)
+      {
+        return null;
+      }
+  }
+
+  /* (non-Javadoc)
+   * @see java.net.SocketImpl#getPort()
+   */
+  protected int getPort()
+  {
+    if (channel == null)
+      return -1;
+    
+    try
+      {
+        InetSocketAddress remote = channel.getVMChannel().getPeerAddress();
+        if (remote == null)
+          return -1;
+        return remote.getPort();
+      }
+    catch (IOException ioe)
+      {
+        return -1;
+      }
+  }
+
   /**
    * This class contains an implementation of <code>InputStream</code> for 
    * sockets.  It in an internal only class used by <code>PlainSocketImpl</code>.
    *
-   * @author Nic Ferrier (nfe...@ta...)
+   * @author Nic Ferrier <nfe...@ta...>
    */
   final class SocketInputStream
     extends InputStream
@@ -465,13 +544,23 @@
      */
     public int read() throws IOException
     {
-      byte buf[] = new byte [1];
-      int bytes_read = read(buf, 0, 1);
- 
-      if (bytes_read == -1)
-        return -1;
-
-      return buf[0] & 0xFF;
+      if (channel == null)
+        throw new SocketException("not connected");
+      while (true)
+        {
+          try
+            {
+              return channel.getVMChannel().read();
+            }
+          catch (SocketTimeoutException ste)
+            {
+              throw ste;
+            }
+          catch (InterruptedIOException iioe)
+            {
+              // Ignore; NIO may throw this; net io shouldn't
+            }
+        }
     }
 
     /**
@@ -488,12 +577,24 @@
      */
     public int read (byte[] buf, int offset, int len) throws IOException
     {
-      int bytes_read = PlainSocketImpl.this.read (buf, offset, len);
-
-      if (bytes_read == 0)
-        return -1;
-
-      return bytes_read;
+      if (channel == null)
+        throw new SocketException("not connected");
+      ByteBuffer b = ByteBuffer.wrap(buf, offset, len);
+      while (true)
+        {
+          try
+            {
+              return channel.read(b);
+            }
+          catch (SocketTimeoutException ste)
+            {
+              throw ste;
+            }
+          catch (InterruptedIOException iioe)
+            {
+              // Ignored; NIO may throw this; net IO not.
+            }
+        }
     }
   }
 
@@ -503,7 +604,7 @@
    * <code>getOutputStream method</code>.  It expects only to  be used in that
    * context.
    *
-   * @author Nic Ferrier (nfe...@ta...)
+   * @author Nic Ferrier  <nfe...@ta...>
    */
   final class SocketOutputStream
     extends OutputStream
@@ -529,8 +630,20 @@
      */
     public void write(int b) throws IOException
     {
-      byte buf[] = { (byte) b };
-      write(buf, 0, 1);
+      if (channel == null)
+        throw new SocketException("not connected");
+      while (true)
+        {
+          try
+            {
+              channel.getVMChannel().write(b);
+              return;
+            }
+          catch (InterruptedIOException iioe)
+            {
+              // Ignored.
+            }
+        }
     }
 
     /**
@@ -545,7 +658,21 @@
      */
     public void write (byte[] buf, int offset, int len) throws IOException
     {
-      PlainSocketImpl.this.write (buf, offset, len);
+      if (channel == null)
+        throw new SocketException("not connected");
+      ByteBuffer b = ByteBuffer.wrap(buf, offset, len);
+      while (b.hasRemaining())
+        {
+          try
+            {
+              if (channel.write(b) == -1)
+                throw new IOException("channel has been closed");
+            }
+          catch (InterruptedIOException iioe)
+            {
+              // Ignored.
+            }
+        }
     }
   }
 }

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/charset/ISO_8859_1.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/charset/ISO_8859_1.java	2006-12-14 10:15:31 UTC (rev 2918)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/charset/ISO_8859_1.java	2006-12-14 10:17:15 UTC (rev 2919)
@@ -128,6 +128,19 @@
       super (cs, 1.0f, 1.0f);
     }
 
+    public boolean canEncode(char c)
+    {
+      return c <= 0xff;
+    }
+
+    public boolean canEncode(CharSequence cs)
+    {
+      for (int i = 0; i < cs.length(); ++i)
+        if (! canEncode(cs.charAt(i)))
+          return false;
+      return true;
+    }
+
     protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
     {
       // TODO: Optimize this in the case in.hasArray() / out.hasArray()

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/charset/US_ASCII.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/charset/US_ASCII.java	2006-12-14 10:15:31 UTC (rev 2918)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/charset/US_ASCII.java	2006-12-14 10:17:15 UTC (rev 2919)
@@ -134,6 +134,19 @@
       super (cs, 1.0f, 1.0f);
     }
 
+    public boolean canEncode(char c)
+    {
+      return c <= 0x7f;
+    }
+
+    public boolean canEncode(CharSequence cs)
+    {
+      for (int i = 0; i < cs.length(); ++i)
+        if (! canEncode(cs.charAt(i)))
+          return false;
+      return true;
+    }
+
     protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
     {
       // TODO: Optimize this in the case in.hasArray() / out.hasArray()
@@ -141,7 +154,7 @@
       {
         char c = in.get ();
 
-        if (c > Byte.MAX_VALUE)
+        if (c > 0x7f)
           {
             in.position (in.position () - 1);
             return CoderResult.unmappableForLength (1);

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/charset/iconv/IconvEncoder.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/charset/iconv/IconvEncoder.java	2006-12-14 10:15:31 UTC (rev 2918)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/charset/iconv/IconvEncoder.java	2006-12-14 10:17:15 UTC (rev 2919)
@@ -43,7 +43,6 @@
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.Charset;
-import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.nio.charset.CoderResult;
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2006	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (97)
2007	Jan (127)	Feb (34)	Mar (16)	Apr (26)	May (55)	Jun (107)	Jul (36)	Aug (72)	Sep (90)	Oct (41)	Nov (27)	Dec (13)
2008	Jan (37)	Feb (39)	Mar (98)	Apr (115)	May (134)	Jun (120)	Jul (86)	Aug (149)	Sep (68)	Oct (66)	Nov (104)	Dec (49)
2009	Jan (131)	Feb (132)	Mar (125)	Apr (172)	May (161)	Jun (43)	Jul (47)	Aug (38)	Sep (18)	Oct (6)	Nov (1)	Dec (15)
2010	Jan (21)	Feb (8)	Mar (10)	Apr (4)	May (9)	Jun	Jul (1)	Aug	Sep	Oct (2)	Nov	Dec (4)
2011	Jan (23)	Feb (10)	Mar (13)	Apr (3)	May	Jun (19)	Jul (11)	Aug (22)	Sep	Oct (4)	Nov (2)	Dec (12)
2012	Jan (3)	Feb (4)	Mar (7)	Apr (3)	May	Jun (1)	Jul (1)	Aug (30)	Sep (3)	Oct (2)	Nov	Dec (8)
2013	Jan (3)	Feb (40)	Mar	Apr	May	Jun (1)	Jul	Aug	Sep	Oct	Nov (12)	Dec
2021	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep (2)	Oct	Nov	Dec

jnode-svn-commits Mailing List for JNode: new Java Operating System (Page 119)

jnode-svn-commits — Subversion commit notifications