/*

 * Copyright (c) 2018, 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 jdk.nio;

import java.io.FileDescriptor;

import java.io.IOException;

import java.nio.channels.SelectableChannel;

import java.nio.channels.SelectionKey;

import java.nio.channels.spi.AbstractSelectableChannel;

import java.nio.channels.spi.SelectorProvider;

import java.util.Objects;

import sun.nio.ch.IOUtil;

import sun.nio.ch.Net;

import sun.nio.ch.SelChImpl;

import sun.nio.ch.SelectionKeyImpl;

import sun.nio.ch.SelectorProviderImpl;

/**

 * Defines static methods to create {@link java.nio.channels.Channel channels}.

 *

 * <p> Unless otherwise specified, passing a {@code null} argument to any of the

 * methods defined here will cause a {@code NullPointerException} to be thrown.

 *

 * @since 11

 */

public final class Channels {

    private Channels() { }

    /**

     * An object used to coordinate the closing of a selectable channel created

     * by {@link Channels#readWriteSelectableChannel readWriteSelectableChannel}.

     *

     * @since 11

     */

    public interface SelectableChannelCloser {

        /**

         * Closes a selectable channel.

         *

         * <p> This method is invoked by the channel's close method in order to

         * perform the actual work of closing the channel. This method is only

         * invoked if the channel has not yet been closed, and it is never

         * invoked more than once by the channel's close implementation.

         *

         * <p> An implementation of this method must arrange for any other

         * thread that is blocked in an I/O operation upon the channel to return

         * immediately, either by throwing an exception or by returning normally.

         * If the channel is {@link SelectableChannel#isRegistered registered}

         * with one or more {@link java.nio.channels.Selector Selector}s then

         * the file descriptor should not be released until the {@link

         * #implReleaseChannel implReleaseChannel} method is invoked. </p>

         *

         * @param  sc

         *         The selectable channel

         *

         * @throws IOException

         *         If an I/O error occurs while closing the file descriptor

         *

         * @see java.nio.channels.spi.AbstractInterruptibleChannel#implCloseChannel

         */

        void implCloseChannel(SelectableChannel sc) throws IOException;

        /**

         * Release the file descriptor and any resources for a selectable

         * channel that closed while registered with one or more {@link

         * java.nio.channels.Selector Selector}s.

         *

         * <p> This method is for cases where a channel is closed when

         * {@link java.nio.channels.SelectableChannel#isRegistered registered}

         * with one or more {@code Selector}s. A channel may remain registered

         * for some time after it is closed. This method is invoked when the

         * channel is eventually deregistered from the last {@code Selector}

         * that it was registered with. It is invoked at most once.

         *

         * @apiNote This method is invoked while synchronized on the selector

         * and its selected-key set. Great care must be taken to avoid deadlocks

         * with other threads that also synchronize on these objects.

         *

         * @param  sc

         *         The closed selectable channel

         *

         * @throws IOException

         *         If an I/O error occurs

         *

         * @see java.nio.channels.spi.AbstractSelector#deregister

         */

        void implReleaseChannel(SelectableChannel sc) throws IOException;

    }

    /**

     * Creates a selectable channel to a file descriptor that supports an

     * {@link SelectableChannel#validOps() operation-set} of

     * {@link SelectionKey#OP_READ OP_READ} and

     * {@link SelectionKey#OP_WRITE OP_WRITE}. The selectable channel will be

     * created by the default {@link SelectorProvider}.

     *

     * <p> The given file descriptor is a socket or resource that can be

     * multiplexed by a {@link java.nio.channels.Selector} for read and write

     * readiness. Great care is required to coordinate direct use of the file

     * descriptor with the use of the selectable channel. In particular,

     * changing the blocking mode or closing the file descriptor without careful

     * coordination will result in unspecified and unsafe side effects. The

     * given {@link SelectableChannelCloser SelectableChannelCloser} is invoked to

     * close the file descriptor and to coordinate the closing when the channel

     * is registered with a {@code Selector}. </p>

     *

     * <p> If there is a security manager set then its

     * {@link SecurityManager#checkRead(FileDescriptor) checkRead} and

     * {@link SecurityManager#checkWrite(FileDescriptor) checkWrite} methods

     * are invoked to check that the caller has permission to both read from and

     * write to the file descriptor. </p>

     *

     * @implNote This method throws {@code UnsupportedOperationException} if

     * the default {@code SelectorProvider} is not the JDK built-in implementation.

     *

     * @param  fd

     *         The file descriptor

     * @param  closer

     *         The object to close the channel

     *

     * @return The selectable channel

     *

     * @throws IllegalArgumentException

     *         If the file descriptor is not {@link FileDescriptor#valid() valid}

     * @throws SecurityException

     *         If denied by the security manager

     */

    public static SelectableChannel readWriteSelectableChannel(FileDescriptor fd,

                                                               SelectableChannelCloser closer) {

        Objects.requireNonNull(closer);

        if (!fd.valid())

            throw new IllegalArgumentException("file descriptor is not valid");

        SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkRead(fd);

            sm.checkWrite(fd);

        }

        SelectorProvider provider = SelectorProvider.provider();

        if (!(provider instanceof SelectorProviderImpl))

            throw new UnsupportedOperationException("custom SelectorProvider");

        return new ReadWriteChannelImpl((SelectorProviderImpl)provider, fd, closer);

    }

    private static final class ReadWriteChannelImpl

        extends AbstractSelectableChannel implements SelChImpl

    {

        private final FileDescriptor fd;

        private final int fdVal;

        private final SelectableChannelCloser closer;

        ReadWriteChannelImpl(SelectorProviderImpl provider,

                             FileDescriptor fd,

                             SelectableChannelCloser closer) {

            super(provider);

            this.fd = fd;

            this.fdVal = IOUtil.fdVal(fd);

            this.closer = closer;

        }

        @Override

        public FileDescriptor getFD() {

            return fd;

        }

        @Override

        public int getFDVal() {

            return fdVal;

        }

        @Override

        public int validOps() {

            return (SelectionKey.OP_READ | SelectionKey.OP_WRITE);

        }

        private boolean translateReadyOps(int ops,

                                          int initialOps,

                                          SelectionKeyImpl ski) {

            int intOps = ski.nioInterestOps();

            int oldOps = ski.nioReadyOps();

            int newOps = initialOps;

            if ((ops & (Net.POLLERR | Net.POLLHUP)) != 0) {

                newOps = intOps;

                ski.nioReadyOps(newOps);

                return (newOps & ~oldOps) != 0;

            }

            if (((ops & Net.POLLIN) != 0) &&

                    ((intOps & SelectionKey.OP_READ) != 0))

                newOps |= SelectionKey.OP_READ;

            if (((ops & Net.POLLOUT) != 0) &&

                    ((intOps & SelectionKey.OP_WRITE) != 0))

                newOps |= SelectionKey.OP_WRITE;

            ski.nioReadyOps(newOps);

            return (newOps & ~oldOps) != 0;

        }

        @Override

        public boolean translateAndUpdateReadyOps(int ops, SelectionKeyImpl ski) {

            return translateReadyOps(ops, ski.nioReadyOps(), ski);

        }

        @Override

        public boolean translateAndSetReadyOps(int ops, SelectionKeyImpl ski) {

            return translateReadyOps(ops, 0, ski);

        }

        @Override

        public int translateInterestOps(int ops) {

            int newOps = 0;

            if ((ops & SelectionKey.OP_READ) != 0)

                newOps |= Net.POLLIN;

            if ((ops & SelectionKey.OP_WRITE) != 0)

                newOps |= Net.POLLOUT;

            return newOps;

        }

        @Override

        protected void implConfigureBlocking(boolean block) throws IOException {

            IOUtil.configureBlocking(fd, block);

        }

        @Override

        protected void implCloseSelectableChannel() throws IOException {

            closer.implCloseChannel(this);

        }

        @Override

        public void kill() throws IOException {

            closer.implReleaseChannel(this);

        }

    }

}