Adding Accepted Socket to Selector

Question

OK,
I have gleaned the java.nio.channels.Selector et al.
I think I understand how to accept a socket. However, once I have; how do I add it to the Selector so that I can register for events on the new connected socket. Here is my source:
Set<SelectionKey> fdset = null;
Socket sock = null;
ServerSocket lstn = null;
selInst = Selector.open();
do
if( null==lstn )
ServerSocketChannel rChan = selInst.provider().openServerSocketChannel();
lstn = rChan.socket();
lstn.bind( new InetSocketAddress(2007) );
rChan.register( selInst, SelectionKey.OP_ACCEPT );
if( 0>selInst.select() )
continue;
fdset = selInst.selectedKeys();
for( SelectionKey key : fdset )
if( key.isAcceptable() )
ServerSocketChannel rCh0 = (ServerSocketChannel)key.channel();
sock = rCh0.socket().accept();
rCh0.register( selInst, SelectionKey.OP_READ )
//xx wait a minute -- ServerSocketChannel::socket() returns a ServerSocket,
//xx not a Socket class, don't I need a new SocketChannel? How do I
//xx attach my accepted socket?
} while( true );
See the comments above. The jist is there is no way to open() a new SocketChannel using an existing Socket class [returned by accept()], as far as I can tell.
Thanks,
James
Beverly, MA

Answer 1

I posted it as an official bug. Here is the tiny app I wrote to reproduce the problem:
* James A. Renton
* Beverly, MA
public class Main
    public Main()
    static void DoOtherWork( )
    {   //xx THIS function symbolizes other stuff
        //xx my thread could do as a result of using NIO
        //xx SUCH AS read and handle internal
        //xx process-specific message queue for
        //xx starting/stopping this thread
        //xx initiating work to be delegated
        //xx to the far end machine this thread communicates with.
        try{ Thread.sleep( 1000 );}catch( Throwable rEx ){/*NOOP*/};
    static ServerSocketChannel listen( Selector rSel, String zItfIP, int nPort )
        try
            ServerSocket sockLstn = null;
            ServerSocketChannel chanLstn = rSel.provider().openServerSocketChannel();
            chanLstn.configureBlocking(false);
            sockLstn = chanLstn.socket();
            sockLstn.bind( new InetSocketAddress(zItfIP,nPort) );
            chanLstn.register( rSel, SelectionKey.OP_ACCEPT );
            return chanLstn;
        catch( java.io.IOException rEx )
            System.out.printf( "accept SETUP FAILED, ERR=[%s]\n", rEx.toString() );
            return null;
    static SocketChannel connect( Selector rSel, String zTargetIP, int nPort )
        try
            SocketChannel chanOut = rSel.provider().openSocketChannel();
            chanOut.configureBlocking(false);
            if( chanOut.connect(new InetSocketAddress(zTargetIP,nPort)) )
                chanOut.register( rSel, SelectionKey.OP_READ );
            else
                chanOut.register( rSel, SelectionKey.OP_CONNECT );
            return chanOut;
        catch( java.io.IOException rEx )
            System.out.printf( "connect SETUP FAILED, ERR=[%s]\n", rEx.toString() );
            return null;
    static Selector GetSel( )
        try { return Selector.open(); }
        catch( java.io.IOException rEx )
            System.out.printf( "Selector.open() FAILED, ERR=[%s]\n", rEx.toString() );
            return null;
    static int DoSelect( Selector rSel, int millis )
        try { return rSel.select( millis ); }
        catch( java.io.IOException rEx )
            System.out.printf( "select() FAILED, ERR=[%s]\n", rEx.toString() );
            return -1;
    public static void main(String[] args)
        int nConnected = 0;
        java.util.Set<SelectionKey> fdset = null;
        System.out.printf( "java.version=[%s]\n", System.getProperty("java.version") );
        System.out.printf( "os.name=[%s]\n", System.getProperty("os.name") );
        System.out.printf( "os.version=[%s]\n", System.getProperty("os.version") );
        Selector selInst = GetSel();
        listen( selInst, "localhost", 2008 );
        connect( selInst, "localhost", 2008 );
        while( 0<=DoSelect(selInst,150) )
            fdset = selInst.selectedKeys();
            if( !fdset.isEmpty() )
                for( SelectionKey key : fdset )
                    try
                        if( key.isAcceptable() )
                            ServerSocketChannel chanLstn = (ServerSocketChannel)key.channel();
                            SocketChannel chanAccept = chanLstn.accept();
                            if( null==chanAccept )
                                System.out.println( "*** BUG0 : KEY FLAGGED ACCEPTING, NOTHING TO ACCEPT!" );
                            else
                                InetSocketAddress addr[] = new InetSocketAddress[2];
                                chanAccept.configureBlocking(false);
                                chanAccept.register( selInst, SelectionKey.OP_READ );
                                addr[0] = (InetSocketAddress)chanAccept.socket().getLocalSocketAddress();
                                addr[1] = (InetSocketAddress)chanAccept.socket().getRemoteSocketAddress();
                                System.out.printf( "ACCEPTED SOCK (%s)<-(%s) OK.\n",
                                                    addr[0].toString(), addr[1].toString() );
                        else if( key.isConnectable() )
                            SocketChannel rCh = (SocketChannel)key.channel();
                            Boolean bRC = rCh.finishConnect();
                            key.interestOps(SelectionKey.OP_READ);
                            if( 0!=nConnected++ )
                                System.out.printf( "*** BUG1 : KEY FLAGGED CONNECTING, ALREADY CONNECTED, RC=[%s]\n",
                                                    bRC.toString() );
                            else
                                InetSocketAddress addr[] = new InetSocketAddress[2];
                                addr[0] = (InetSocketAddress)rCh.socket().getLocalSocketAddress();
                                addr[1] = (InetSocketAddress)rCh.socket().getRemoteSocketAddress();
                                System.out.printf( "CONNECT SOCK (%s)->(%s) OK, RC=[%s]\n",
                                                    addr[0].toString(), addr[1].toString(), bRC.toString() );
                    catch( java.io.IOException rEx )
                        System.out.printf( "UnHandled IOException, ERR=[%s]", rEx.toString() );
                        rEx.printStackTrace();
            DoOtherWork();
}