/*

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.nio.ch;

import java.io.FileDescriptor;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.BufferPoolMXBean;

import java.nio.channels.*;

import java.util.ArrayList;

import java.util.List;

import java.util.Iterator;

import java.lang.reflect.Field;

import java.security.AccessController;

import javax.management.ObjectName;

import javax.management.MalformedObjectNameException;

import sun.misc.Cleaner;

import sun.security.action.GetPropertyAction;

public class FileChannelImpl

    extends FileChannel

{

    // Used to make native read and write calls

    // Memory allocation size for mapping buffers

    private static final long allocationGranularity;

    // File descriptor

    private final FileDescriptor fd;

    // File access mode (immutable)

    private final boolean writable;

    private final boolean readable;

    // Required to prevent finalization of creating stream (immutable)

    private final Object parent;

    // Thread-safe set of IDs of native threads, for signalling

    private final NativeThreadSet threads = new NativeThreadSet(2);

    // Lock for operations involving position and size

    private final Object positionLock = new Object();

    private FileChannelImpl(FileDescriptor fd, boolean readable,

                            boolean writable, Object parent)

    {

        this.fd = fd;

        this.readable = readable;

        this.writable = writable;

        this.parent = parent;

    }

    // Invoked by getChannel() methods

    // of java.io.File{Input,Output}Stream and RandomAccessFile

    //

    public static FileChannel open(FileDescriptor fd,

                                   boolean readable, boolean writable,

                                   Object parent)

    {

        return new FileChannelImpl(fd, readable, writable, parent);

    }

    private void ensureOpen() throws IOException {

        if (!isOpen())

            throw new ClosedChannelException();

    }

    // -- Standard channel operations --

    protected void implCloseChannel() throws IOException {

        // Invalidate and release any locks that we still hold

        if (fileLockTable != null) {

            fileLockTable.removeAll( new FileLockTable.Releaser() {

                public void release(FileLock fl) throws IOException {

                    ((FileLockImpl)fl).invalidate();

                }

            });

        }

        if (parent != null) {

            // Close the fd via the parent stream's close method.  The parent

            // will reinvoke our close method, which is defined in the

            // superclass AbstractInterruptibleChannel, but the isOpen logic in

            // that method will prevent this method from being reinvoked.

            //

            ((java.io.Closeable)parent).close();

        } else {

            nd.close(fd);

        }

    }

    public int read(ByteBuffer dst) throws IOException {

        ensureOpen();

        if (!readable)

            throw new NonReadableChannelException();

        synchronized (positionLock) {

            int n = 0;

            try {

                begin();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.read(fd, dst, -1, nd, positionLock);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                end(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    private long read0(ByteBuffer[] dsts) throws IOException {

        ensureOpen();

        if (!readable)

            throw new NonReadableChannelException();

        synchronized (positionLock) {

            long n = 0;

            try {

                begin();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.read(fd, dsts, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                end(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    public long read(ByteBuffer[] dsts, int offset, int length)

        throws IOException

    {

        if ((offset < 0) || (length < 0) || (offset > dsts.length - length))

           throw new IndexOutOfBoundsException();

        // ## Fix IOUtil.write so that we can avoid this array copy

        return read0(Util.subsequence(dsts, offset, length));

    }

    public int write(ByteBuffer src) throws IOException {

        ensureOpen();

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            int n = 0;

            try {

                begin();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.write(fd, src, -1, nd, positionLock);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                end(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    private long write0(ByteBuffer[] srcs) throws IOException {

        ensureOpen();

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            long n = 0;

            try {

                begin();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.write(fd, srcs, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                end(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    public long write(ByteBuffer[] srcs, int offset, int length)

        throws IOException

    {

        if ((offset < 0) || (length < 0) || (offset > srcs.length - length))

           throw new IndexOutOfBoundsException();

        // ## Fix IOUtil.write so that we can avoid this array copy

        return write0(Util.subsequence(srcs, offset, length));

    }

    // -- Other operations --

    public long position() throws IOException {

        ensureOpen();

        synchronized (positionLock) {

            long p = -1;

            try {

                begin();

                if (!isOpen())

                    return 0;

                do {

                    p = position0(fd, -1);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(p);

            } finally {

                threads.remove(ti);

                end(p > -1);

                assert IOStatus.check(p);

            }

        }

    }

    public FileChannel position(long newPosition) throws IOException {

        ensureOpen();

        if (newPosition < 0)

            throw new IllegalArgumentException();

        synchronized (positionLock) {

            long p = -1;

            try {

                begin();

                if (!isOpen())

                    return null;

                do {

                    p  = position0(fd, newPosition);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                return this;

            } finally {

                threads.remove(ti);

                end(p > -1);

                assert IOStatus.check(p);

            }

        }

    }

    public long size() throws IOException {

        ensureOpen();

        synchronized (positionLock) {

            long s = -1;

            try {

                begin();

                if (!isOpen())

                    return -1;

                do {

                } while ((s == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(s);

            } finally {

                threads.remove(ti);

                end(s > -1);

                assert IOStatus.check(s);

            }

        }

    }

    public FileChannel truncate(long size) throws IOException {

        ensureOpen();

        if (size < 0)

            throw new IllegalArgumentException();

        if (size > size())

            return this;

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            int rv = -1;

            long p = -1;

            try {

                begin();

                if (!isOpen())

                    return null;

                // get current position

                do {

                    p = position0(fd, -1);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                if (!isOpen())

                    return null;

                assert p >= 0;

                // truncate file

                do {

                } while ((rv == IOStatus.INTERRUPTED) && isOpen());

                if (!isOpen())

                    return null;

                // set position to size if greater than size

                if (p > size)

                    p = size;

                do {

                    rv = (int)position0(fd, p);

                } while ((rv == IOStatus.INTERRUPTED) && isOpen());

                return this;

            } finally {

                threads.remove(ti);

                end(rv > -1);

                assert IOStatus.check(rv);

            }

        }

    }

    public void force(boolean metaData) throws IOException {

        ensureOpen();

        int rv = -1;

        try {

            begin();

            if (!isOpen())

                return;

            do {

            } while ((rv == IOStatus.INTERRUPTED) && isOpen());

        } finally {

            threads.remove(ti);

            end(rv > -1);

            assert IOStatus.check(rv);

        }

    }

    // Assume at first that the underlying kernel supports sendfile();

    // set this to false if we find out later that it doesn't

    //

    private static volatile boolean transferSupported = true;

    // Assume that the underlying kernel sendfile() will work if the target

    // fd is a pipe; set this to false if we find out later that it doesn't

    //

    private static volatile boolean pipeSupported = true;

    // Assume that the underlying kernel sendfile() will work if the target

    // fd is a file; set this to false if we find out later that it doesn't

    //

    private static volatile boolean fileSupported = true;

    private long transferToDirectly(long position, int icount,

                                    WritableByteChannel target)

        throws IOException

    {

        if (!transferSupported)

            return IOStatus.UNSUPPORTED;

        FileDescriptor targetFD = null;

        if (target instanceof FileChannelImpl) {

            if (!fileSupported)

                return IOStatus.UNSUPPORTED_CASE;

            targetFD = ((FileChannelImpl)target).fd;

        } else if (target instanceof SelChImpl) {

            // Direct transfer to pipe causes EINVAL on some configurations

            if ((target instanceof SinkChannelImpl) && !pipeSupported)

                return IOStatus.UNSUPPORTED_CASE;

            targetFD = ((SelChImpl)target).getFD();

        }

        if (targetFD == null)

            return IOStatus.UNSUPPORTED;

        int thisFDVal = IOUtil.fdVal(fd);

        int targetFDVal = IOUtil.fdVal(targetFD);

        if (thisFDVal == targetFDVal) // Not supported on some configurations

            return IOStatus.UNSUPPORTED;

        long n = -1;

        try {

            begin();

            if (!isOpen())

                return -1;

            do {

                n = transferTo0(thisFDVal, position, icount, targetFDVal);

            } while ((n == IOStatus.INTERRUPTED) && isOpen());

            if (n == IOStatus.UNSUPPORTED_CASE) {

                if (target instanceof SinkChannelImpl)

                    pipeSupported = false;

                if (target instanceof FileChannelImpl)

                    fileSupported = false;

                return IOStatus.UNSUPPORTED_CASE;

            }

            if (n == IOStatus.UNSUPPORTED) {

                // Don't bother trying again

                transferSupported = false;

                return IOStatus.UNSUPPORTED;

            }

            return IOStatus.normalize(n);

        } finally {

            threads.remove(ti);

            end (n > -1);

        }

    }

    private long transferToTrustedChannel(long position, int icount,

                                          WritableByteChannel target)

        throws IOException

    {

        if (  !((target instanceof FileChannelImpl)

                || (target instanceof SelChImpl)))

            return IOStatus.UNSUPPORTED;

        // Trusted target: Use a mapped buffer

        MappedByteBuffer dbb = null;

        try {

            dbb = map(MapMode.READ_ONLY, position, icount);

            // ## Bug: Closing this channel will not terminate the write

            return target.write(dbb);

        } finally {

            if (dbb != null)

                unmap(dbb);

        }

    }

    private long transferToArbitraryChannel(long position, int icount,

                                            WritableByteChannel target)

        throws IOException

    {

        // Untrusted target: Use a newly-erased buffer

        int c = Math.min(icount, TRANSFER_SIZE);

        ByteBuffer bb = Util.getTemporaryDirectBuffer(c);

        long tw = 0;                    // Total bytes written

        long pos = position;

        try {

            Util.erase(bb);

            while (tw < icount) {

                bb.limit(Math.min((int)(icount - tw), TRANSFER_SIZE));

                int nr = read(bb, pos);

                if (nr <= 0)

                    break;

                bb.flip();

                // ## Bug: Will block writing target if this channel

                // ##      is asynchronously closed

                int nw = target.write(bb);

                tw += nw;

                if (nw != nr)

                    break;

                pos += nw;

                bb.clear();

            }

            return tw;

        } catch (IOException x) {

            if (tw > 0)

                return tw;

            throw x;

        } finally {

            Util.releaseTemporaryDirectBuffer(bb);

        }

    }

    public long transferTo(long position, long count,

                           WritableByteChannel target)

        throws IOException

    {

        ensureOpen();

        if (!target.isOpen())

            throw new ClosedChannelException();

        if (!readable)

            throw new NonReadableChannelException();

        if (target instanceof FileChannelImpl &&

            !((FileChannelImpl)target).writable)

            throw new NonWritableChannelException();

        if ((position < 0) || (count < 0))

            throw new IllegalArgumentException();

        long sz = size();

        if (position > sz)

            return 0;

        int icount = (int)Math.min(count, Integer.MAX_VALUE);

        if ((sz - position) < icount)

            icount = (int)(sz - position);

        long n;

        // Attempt a direct transfer, if the kernel supports it

        if ((n = transferToDirectly(position, icount, target)) >= 0)

            return n;

        // Attempt a mapped transfer, but only to trusted channel types

        if ((n = transferToTrustedChannel(position, icount, target)) >= 0)

            return n;

        // Slow path for untrusted targets