public ChannelInputStream(ReadableByteChannel ch) 
{
       
        this.ch = ch;
}

 public  void close() throws IOException 
{
        ch.close();
}

 public synchronized int read() throws IOException 
{
        if (b1 == null)
            b1 = new byte[1];
        int n = this.read(b1);
        if (n == 1)
            return b1[0] & 0xff;
        return -1;
}

 protected int read(ByteBuffer bb) throws IOException 
{
        return ChannelInputStream.read(ch, bb, true);
}

 public static int read(ReadableByteChannel ch,
    ByteBuffer bb,
    boolean block) throws IOException 
{
        if (ch instanceof SelectableChannel) {
            SelectableChannel sc = (SelectableChannel)ch;
            synchronized (sc.blockingLock()) {
                boolean bm = sc.isBlocking();
                if (!bm)
                    throw new IllegalBlockingModeException();
                if (bm != block)
                    sc.configureBlocking(block);
                int n = ch.read(bb);
                if (bm != block)
                    sc.configureBlocking(bm);
                return n;
            }
        } else {
            return ch.read(bb);
        }
}

 public synchronized int read(byte[] bs,
    int off,
    int len) throws IOException 
{
        if ((off <  0) || (off  > bs.length) || (len <  0) ||
            ((off + len)  > bs.length) || ((off + len) <  0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0)
            return 0;
        ByteBuffer bb = ((this.bs == bs)
                         ? this.bb
                         : ByteBuffer.wrap(bs));
        bb.limit(Math.min(off + len, bb.capacity()));
        bb.position(off);
        this.bb = bb;
        this.bs = bs;
        return read(bb);
}