libjava/gnu/java/nio/SocketChannelImpl.java

   1 /* SocketChannelImpl.java --
   2    Copyright (C) 2002 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 gnu.java.nio;
  39
  40 import java.io.IOException;
  41 import java.net.InetAddress;
  42 import java.net.InetSocketAddress;
  43 import java.net.Socket;
  44 import java.net.SocketAddress;
  45 import java.nio.ByteBuffer;
  46 import java.nio.channels.AlreadyConnectedException;
  47 import java.nio.channels.SocketChannel;
  48 import java.nio.channels.spi.SelectorProvider;
  49 import gnu.classpath.Configuration;
  50
  51 public class SocketChannelImpl extends SocketChannel
  52 {
  53   Socket sock_object;
  54   int fd;
  55   int local_port;
  56   boolean blocking = true;
  57   boolean connected = false;
  58   InetSocketAddress sa;
  59
  60   static native int SocketCreate();
  61   static native int SocketConnect(int fd, InetAddress addr, int port);
  62   static native int SocketBind(int fd, InetAddress addr, int port);
  63   static native int SocketListen(int fd, int backlog);
  64   static native int SocketAvailable(int fd);
  65   static native int SocketClose(int fd);
  66   static native int SocketRead(int fd, byte b[], int off, int len);
  67   static native int SocketWrite(int fd, byte b[], int off, int len);
  68
  69   public SocketChannelImpl(SelectorProvider provider)
  70   {
  71     super(provider);
  72     fd = SocketCreate();
  73
  74     if (fd == -1)
  75             {
  76         System.err.println("failed to create socket:"+fd);
  77             }
  78   }
  79
  80   public void finalizer()
  81   {
  82     if (connected)
  83             {
  84         try
  85           {
  86             close();
  87           }
  88         catch (Exception e)
  89           {
  90           }
  91             }
  92   }
  93
  94   protected void implCloseSelectableChannel()
  95   {
  96     connected = false;
  97     SocketClose(fd);
  98     fd = SocketCreate();
  99   }
 100
 101   protected void implConfigureBlocking(boolean  block)
 102   {
 103     if (blocking == block)
 104             return;
 105   }
 106
 107   public boolean connect(SocketAddress remote)
 108     throws IOException
 109   {
 110     if (connected)
 111             {
 112         throw new AlreadyConnectedException();
 113             }
 114
 115     // ok, lets connect !
 116
 117     sa = (InetSocketAddress) remote;
 118
 119     InetAddress addr = sa.getAddress();
 120     int port = sa.getPort();
 121     int err = SocketConnect(fd, addr, port);
 122
 123     if (err < 0)
 124             {
 125         throw new IOException("Connection refused:"+err + ", connect="+err);
 126             }
 127
 128     local_port = err;
 129     connected = true;
 130     return blocking;
 131   }
 132
 133   public boolean finishConnect()
 134   {
 135     return false;
 136   }
 137
 138   public boolean isConnected()
 139   {
 140     return connected;
 141   }
 142
 143   public boolean isConnectionPending()
 144   {
 145     if (blocking)
 146             return true;
 147
 148     return false;
 149   }
 150
 151   public Socket socket()
 152   {
 153     if (sock_object != null)
 154             {
 155         //sock_object.ch = this;
 156             }
 157
 158     return sock_object;
 159   }
 160
 161   public int read(ByteBuffer dst)
 162   {
 163     int bytes = 0;
 164     int len = 1024;
 165     byte[]b = new byte[len];
 166
 167     bytes = SocketRead(fd, b, 0, len);
 168     dst.put(b, 0, bytes);
 169
 170     if (bytes == 0)
 171             {
 172         // we've hit eof ?
 173         return -1;
 174             }
 175
 176     return bytes;
 177   }
 178
 179   public long read(ByteBuffer[] dsts, int offset, int length)
 180   {
 181     long bytes = 0;
 182
 183     for (int i=offset; i<length; i++)
 184             {
 185         bytes += read(dsts[i]);
 186             }
 187
 188     return bytes;
 189   }
 190
 191   public int write(ByteBuffer src)
 192   {
 193     int bytes = 0;
 194     int len = src.position();
 195
 196     if (src instanceof ByteBufferImpl)
 197             {
 198         ByteBufferImpl bi = (ByteBufferImpl) src;
 199         byte[]b = bi.array();
 200         bytes = SocketWrite(fd, b, 0, len);
 201             }
 202     else
 203             {
 204         byte[]b = new byte[len];
 205         src.get(b, 0, len);
 206         bytes = SocketWrite(fd, b, 0, len);
 207             }
 208
 209           return bytes;
 210   }
 211
 212   public long write (ByteBuffer[] srcs, int offset, int length)
 213   {
 214     long bytes = 0;
 215
 216     for (int i=offset; i<length; i++)
 217             {
 218         bytes += write(srcs[i]);
 219             }
 220
 221     return bytes;
 222   }
 223 }