libjava/gnu/java/nio/SocketChannelImpl.java

   1 /* SocketChannelImpl.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
  39 package gnu.java.nio;
  40
  41 import java.io.InputStream;
  42 import java.io.IOException;
  43 import java.io.OutputStream;
  44 import java.net.InetAddress;
  45 import java.net.InetSocketAddress;
  46 import gnu.java.net.PlainSocketImpl;
  47 import java.net.Socket;
  48 import java.net.SocketAddress;
  49 import java.net.SocketTimeoutException;
  50 import java.nio.ByteBuffer;
  51 import java.nio.channels.AlreadyConnectedException;
  52 import java.nio.channels.ClosedChannelException;
  53 import java.nio.channels.ConnectionPendingException;
  54 import java.nio.channels.NoConnectionPendingException;
  55 import java.nio.channels.NotYetConnectedException;
  56 import java.nio.channels.UnresolvedAddressException;
  57 import java.nio.channels.UnsupportedAddressTypeException;
  58 import java.nio.channels.SocketChannel;
  59 import java.nio.channels.Selector;
  60 import java.nio.channels.SelectionKey;
  61 import java.nio.channels.spi.SelectorProvider;
  62 import gnu.classpath.Configuration;
  63
  64 public final class SocketChannelImpl extends SocketChannel
  65 {
  66   private NIOSocket socket;
  67   private boolean blocking = true;
  68   private boolean connected = false;
  69   private boolean connectionPending = false;
  70
  71   SocketChannelImpl (SelectorProvider provider)
  72     throws IOException
  73   {
  74     super (provider);
  75     socket = new NIOSocket (new PlainSocketImpl(), this);
  76   }
  77
  78   SocketChannelImpl (SelectorProvider provider,
  79                      NIOSocket socket)
  80     throws IOException
  81   {
  82     super (provider);
  83     this.socket = socket;
  84     this.connected = socket.isConnected();
  85   }
  86
  87   public void finalizer()
  88   {
  89     if (isConnected())
  90       {
  91         try
  92           {
  93             close ();
  94           }
  95         catch (Exception e)
  96           {
  97           }
  98       }
  99   }
 100
 101   int getNativeFD()
 102   {
 103     return socket.getImpl().getNativeFD();
 104   }
 105
 106   protected void implCloseSelectableChannel () throws IOException
 107   {
 108     connected = false;
 109     socket.close();
 110   }
 111
 112   protected void implConfigureBlocking (boolean blocking) throws IOException
 113   {
 114     socket.setSoTimeout (blocking ? 0 : NIOConstants.DEFAULT_TIMEOUT);
 115     this.blocking = blocking;
 116   }
 117
 118   public boolean connect (SocketAddress remote) throws IOException
 119   {
 120     if (!isOpen())
 121       throw new ClosedChannelException();
 122
 123     if (isConnected())
 124       throw new AlreadyConnectedException();
 125
 126     if (connectionPending)
 127       throw new ConnectionPendingException();
 128
 129     if (!(remote instanceof InetSocketAddress))
 130       throw new UnsupportedAddressTypeException();
 131
 132     if (((InetSocketAddress) remote).isUnresolved())
 133       throw new UnresolvedAddressException();
 134
 135     if (blocking)
 136       {
 137         // Do blocking connect.
 138         socket.connect (remote);
 139         connected = true;
 140         return true;
 141       }
 142
 143     // Do non-blocking connect.
 144     try
 145       {
 146         socket.connect (remote, NIOConstants.DEFAULT_TIMEOUT);
 147         connected = true;
 148         return true;
 149       }
 150     catch (SocketTimeoutException e)
 151       {
 152         connectionPending = true;
 153         return false;
 154       }
 155   }
 156
 157   public boolean finishConnect ()
 158     throws IOException
 159   {
 160     if (!isOpen())
 161       throw new ClosedChannelException();
 162
 163     if (!connectionPending)
 164       throw new NoConnectionPendingException();
 165
 166     if (isConnected())
 167       return true;
 168
 169     // FIXME: Handle blocking/non-blocking mode.
 170
 171     Selector selector = provider().openSelector();
 172     register (selector, SelectionKey.OP_CONNECT);
 173
 174     if (isBlocking())
 175       {
 176         selector.select(); // blocking until channel is connected.
 177         connected = true;
 178         connectionPending = false;
 179         return true;
 180       }
 181
 182     int ready = selector.selectNow(); // non-blocking
 183     if (ready == 1)
 184       {
 185         connected = true;
 186         connectionPending = false;
 187         return true;
 188       }
 189
 190     return false;
 191   }
 192
 193   public boolean isConnected ()
 194   {
 195     return connected;
 196   }
 197
 198   public boolean isConnectionPending ()
 199   {
 200     return connectionPending;
 201   }
 202
 203   public Socket socket ()
 204   {
 205     return socket;
 206   }
 207
 208   public int read (ByteBuffer dst) throws IOException
 209   {
 210     if (!connected)
 211       throw new NotYetConnectedException();
 212
 213     byte[] data;
 214     int offset = 0;
 215     int len = dst.remaining();
 216
 217     if (dst.hasArray())
 218       {
 219         offset = dst.arrayOffset() + dst.position();
 220         data = dst.array();
 221       }
 222     else
 223       {
 224         data = new byte [len];
 225       }
 226
 227     InputStream input = socket.getInputStream();
 228     int available = input.available();
 229
 230     if (available == 0)
 231       return 0;
 232
 233     if (len > available)
 234       len = available;
 235
 236     int readBytes = 0;
 237     boolean completed = false;
 238
 239     try
 240       {
 241         begin();
 242         readBytes = input.read (data, offset, len);
 243         completed = true;
 244       }
 245     finally
 246       {
 247         end (completed);
 248       }
 249
 250     if (readBytes > 0
 251         && !dst.hasArray())
 252       {
 253         dst.put (data);
 254       }
 255
 256     return readBytes;
 257   }
 258
 259   public long read (ByteBuffer[] dsts, int offset, int length)
 260     throws IOException
 261   {
 262     if (!connected)
 263       throw new NotYetConnectedException();
 264
 265     if ((offset < 0)
 266         || (offset > dsts.length)
 267         || (length < 0)
 268         || (length > (dsts.length - offset)))
 269       throw new IndexOutOfBoundsException();
 270
 271     long readBytes = 0;
 272
 273     for (int index = offset; index < length; index++)
 274       readBytes += read (dsts [index]);
 275
 276     return readBytes;
 277   }
 278
 279   public int write (ByteBuffer src)
 280     throws IOException
 281   {
 282     if (!connected)
 283       throw new NotYetConnectedException();
 284
 285     byte[] data;
 286     int offset = 0;
 287     int len = src.remaining();
 288
 289     if (!src.hasArray())
 290       {
 291         data = new byte [len];
 292         src.get (data, 0, len);
 293       }
 294     else
 295       {
 296         offset = src.arrayOffset() + src.position();
 297         data = src.array();
 298       }
 299
 300     System.out.println ("INTERNAL: writing to socket outputstream");
 301
 302     OutputStream output = socket.getOutputStream();
 303     output.write (data, offset, len);
 304     return len;
 305   }
 306
 307   public long write (ByteBuffer[] srcs, int offset, int length)
 308     throws IOException
 309   {
 310     if (!connected)
 311       throw new NotYetConnectedException();
 312
 313     if ((offset < 0)
 314         || (offset > srcs.length)
 315         || (length < 0)
 316         || (length > (srcs.length - offset)))
 317       throw new IndexOutOfBoundsException();
 318
 319     long writtenBytes = 0;
 320
 321     for (int index = offset; index < length; index++)
 322       writtenBytes += write (srcs [index]);
 323
 324     return writtenBytes;
 325   }
 326 }