/*
 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 */

package sun.nio.ch;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import java.util.Random;


/**
 * A simple Pipe implementation based on a socket connection.
 */

class PipeImpl
    extends Pipe
{

    // Source and sink channels
    private SourceChannel source;
    private SinkChannel sink;

    // Random object for handshake values
    private static final Random rnd;

    static {
        Util.load();
        byte[] someBytes = new byte[8];
        boolean resultOK = IOUtil.randomBytes(someBytes);
        if (resultOK) {
            rnd = new Random(ByteBuffer.wrap(someBytes).getLong());
        } else {
            rnd = new Random();
        }
    }

    private class Initializer
        implements PrivilegedExceptionAction<Void>
    {

        private final SelectorProvider sp;

        private IOException ioe = null;

        private Initializer(SelectorProvider sp) {
            this.sp = sp;
        }

        @Override
        public Void run() throws IOException {
            boolean interrupted = false;

            ServerSocketChannel ssc = null;
            SocketChannel sc1 = null;
            SocketChannel sc2 = null;

            try {
                // loopback address
                InetAddress lb = InetAddress.getByName("127.0.0.1");
                assert(lb.isLoopbackAddress());
                InetSocketAddress sa = null;
                for(;;) {
                    // bind ServerSocketChannel to a port on the loopback
                    // address
                    if (ssc == null || !ssc.isOpen()) {
                        ssc = ServerSocketChannel.open();
                        ssc.socket().bind(new InetSocketAddress(lb, 0));
                        sa = new InetSocketAddress(lb,
                                ssc.socket().getLocalPort());
                    }

                    // Establish connection (assume connections are eagerly
                    // accepted)
                    sc1 = SocketChannel.open(sa);
                    ByteBuffer bb = ByteBuffer.allocate(8);
                    long secret = rnd.nextLong();
                    bb.putLong(secret).flip();
                    sc1.write(bb);

                    // Get a connection and verify it is legitimate
                    sc2 = ssc.accept();
                    bb.clear();
                    sc2.read(bb);
                    bb.rewind();
                    if (bb.getLong() == secret)
                        break;
                    sc2.close();
                    sc1.close();
                }

                // Create source and sink channels
                source = new SourceChannelImpl(sp, sc1);
                sink = new SinkChannelImpl(sp, sc2);
            } catch (IOException e) {
                try {
                    if (sc1 != null)
                        sc1.close();
                    if (sc2 != null)
                        sc2.close();
                } catch (IOException e2) {}

                if (!(e instanceof ClosedByInterruptException))
                    throw new IOException("Unable to establish loopback"
                            + " connection", e);
                interrupted = true;
                Thread.interrupted();
            } finally {
                try {
                    if (ssc != null)
                        ssc.close();
                } catch (IOException e2) {}
            }

            if (interrupted)
                UninterruptibleConnect();

            return null;
        }

        // Use short-lived uninterruptible thread to establish
        // loopback connections
        private void UninterruptibleConnect() throws IOException {
            Thread connector = new Thread("UninterruptibleConnector") {
                ServerSocketChannel ssc = null;
                SocketChannel sc1 = null;
                SocketChannel sc2 = null;

                @Override
                public void run() {
                    try {
                        // loopback address
                        InetAddress lb = InetAddress.getByName("127.0.0.1");
                        assert(lb.isLoopbackAddress());
                        InetSocketAddress sa = null;

                        for (;;) {
                            // bind ServerSocketChannel to a port on the
                            // loopback address
                            if (ssc == null || !ssc.isOpen()) {
                                ssc = ServerSocketChannel.open();
                                ssc.socket().bind(new InetSocketAddress(lb, 0));
                                sa = new InetSocketAddress(lb,
                                        ssc.socket().getLocalPort());
                            }
                            assert(sa != null);

                            // Establish connection (assumes connections are
                            // eagerly accepted)
                            sc1 = SocketChannel.open(sa);
                            ByteBuffer bb = ByteBuffer.allocate(8);
                            long secret = rnd.nextLong();
                            bb.putLong(secret).flip();
                            sc1.write(bb);

                            // Get a connection and verify it is legitimate
                            sc2 = ssc.accept();
                            bb.clear();
                            sc2.read(bb);
                            bb.rewind();
                            if (bb.getLong() == secret)
                                break;
                            sc2.close();
                            sc1.close();
                        }

                        // Create source and sink channels
                        source = new SourceChannelImpl(sp, sc1);
                        sink = new SinkChannelImpl(sp, sc2);
                    } catch (IOException e) {
                        try {
                            if (sc1 != null)
                                sc1.close();
                            if (sc2 != null)
                                sc2.close();
                        } catch (IOException e2) {}
                        ioe = e;
                    } finally {
                        try {
                            if (ssc != null)
                                ssc.close();
                        } catch (IOException e2) {}
                    }
                }

                @Override
                public void interrupt() {}
            };
            connector.start();
            for(;;) {
                try {
                    connector.join();
                    break;
                } catch (InterruptedException ex) {}
            }

            Thread.currentThread().interrupt();

            if (ioe != null || source == null || sink == null)
                throw new IOException("Unable to establish loopback connection",
                        ioe);
        }
    }

    PipeImpl(final SelectorProvider sp) throws IOException {
        try {
            AccessController.doPrivileged(new Initializer(sp));
        } catch (PrivilegedActionException x) {
            throw (IOException)x.getCause();
        }
    }


    public SourceChannel source() {
        return source;
    }

    public SinkChannel sink() {
        return sink;
    }

}