android-15.0.0_r3/s

/*
 * Copyright (c) 1995, 2011, 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 java.io;

import android.system.ErrnoException;
import android.system.Os;
import android.system.OsConstants;

import static android.system.OsConstants.F_DUPFD_CLOEXEC;

import dalvik.annotation.optimization.CriticalNative;

import libcore.io.Libcore;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Instances of the file descriptor class serve as an opaque handle
 * to the underlying machine-specific structure representing an open
 * file, an open socket, or another source or sink of bytes. The
 * main practical use for a file descriptor is to create a
 * <code>FileInputStream</code> or <code>FileOutputStream</code> to
 * contain it.
 * <p>
 * Applications should not create their own file descriptors.
 *
 * @author  Pavani Diwanji
 * @see     java.io.FileInputStream
 * @see     java.io.FileOutputStream
 * @since   JDK1.0
 */
public final class FileDescriptor {
    // Android-changed: Removed parent reference counting.
    // The creator is responsible for closing the file descriptor.

    // Android-changed: Renamed fd to descriptor.
    // Renaming is to avoid issues with JNI/reflection fetching the descriptor value.
    private int descriptor;

    // Android-added: Track fd owner to guard against accidental closure. http://b/110100358
    // The owner on the libc side is an pointer-sized value that can be set to an arbitrary
    // value (with 0 meaning 'unowned'). libcore chooses to use System.identityHashCode.
    private long ownerId = NO_OWNER;

    /**
     * true, if file is opened for appending.
     */
    private boolean append;

    // Android-added: value of ownerId indicating that a FileDescriptor is unowned.
    /** @hide */
    public static final long NO_OWNER = 0L;

    // Android-added: lock for release$.
    private final Object releaseLock = new Object();

    /**
     * Constructs an (invalid) FileDescriptor
     * object.
     */
    public /**/ FileDescriptor() {
        descriptor = -1;
    }

    private /* */ FileDescriptor(int fd) {
        this.descriptor = fd;
        this.append = getAppend(fd);
    }

    /**
     * A handle to the standard input stream. Usually, this file
     * descriptor is not used directly, but rather via the input stream
     * known as <code>System.in</code>.
     *
     * @see     java.lang.System#in
     */
    public static final FileDescriptor in = new FileDescriptor(0);

    /**
     * A handle to the standard output stream. Usually, this file
     * descriptor is not used directly, but rather via the output stream
     * known as <code>System.out</code>.
     * @see     java.lang.System#out
     */
    public static final FileDescriptor out = new FileDescriptor(1);

    /**
     * A handle to the standard error stream. Usually, this file
     * descriptor is not used directly, but rather via the output stream
     * known as <code>System.err</code>.
     *
     * @see     java.lang.System#err
     */
    public static final FileDescriptor err = new FileDescriptor(2);

    /**
     * Tests if this file descriptor object is valid.
     *
     * @return  <code>true</code> if the file descriptor object represents a
     *          valid, open file, socket, or other active I/O connection;
     *          <code>false</code> otherwise.
     */
    public boolean valid() {
        return descriptor != -1;
    }

    /**
     * Force all system buffers to synchronize with the underlying
     * device.  This method returns after all modified data and
     * attributes of this FileDescriptor have been written to the
     * relevant device(s).  In particular, if this FileDescriptor
     * refers to a physical storage medium, such as a file in a file
     * system, sync will not return until all in-memory modified copies
     * of buffers associated with this FileDescriptor have been
     * written to the physical medium.
     *
     * sync is meant to be used by code that requires physical
     * storage (such as a file) to be in a known state  For
     * example, a class that provided a simple transaction facility
     * might use sync to ensure that all changes to a file caused
     * by a given transaction were recorded on a storage medium.
     *
     * sync only affects buffers downstream of this FileDescriptor.  If
     * any in-memory buffering is being done by the application (for
     * example, by a BufferedOutputStream object), those buffers must
     * be flushed into the FileDescriptor (for example, by invoking
     * OutputStream.flush) before that data will be affected by sync.
     *
     * @exception SyncFailedException
     *        Thrown when the buffers cannot be flushed,
     *        or because the system cannot guarantee that all the
     *        buffers have been synchronized with physical media.
     * @since     JDK1.1
     */
    public native void sync() throws SyncFailedException;

    // Android-removed: initIDs not used to allow compile-time initialization.
    /* This routine initializes JNI field offsets for the class */
    //private static native void initIDs();

    /**
     * Returns true, if the file was opened for appending.
     */
    @CriticalNative
    private static native boolean getAppend(int fd);

    // Android-added: Needed for framework to access descriptor value.
    /**
     * Returns the int descriptor. It's highly unlikely you should be calling this. Please discuss
     * your needs with a libcore maintainer before using this method.
     * @hide internal use only
     */
    public final int getInt$() {
        return descriptor;
    }

    // Android-added: Needed for framework to access descriptor value.
    /**
     * Sets the int descriptor. It's highly unlikely you should be calling this. Please discuss
     * your needs with a libcore maintainer before using this method.
     *
     * @hide This method is @SystemApi(MODULE_LIBRARIES) and used by AFileDescriptor_setFd.
     */
    public final void setInt$(int fd) {
        this.descriptor = fd;
        if (fd != -1) {
            this.append = getAppend(fd);
        }
    }

    // BEGIN Android-added: Method to clone standard file descriptors.
    // Required as a consequence of RuntimeInit#redirectLogStreams. Cloning is used in
    // ZygoteHooks.onEndPreload().
    /**
     * Clones the current native file descriptor and uses this for this FileDescriptor instance.
     *
     * This method does not close the current native file descriptor.
     *
     * @hide internal use only
     */
    public void cloneForFork() {
        try {
            int newDescriptor = Os.fcntlInt(this, F_DUPFD_CLOEXEC, 0);
            setInt$(newDescriptor);
        } catch (ErrnoException e) {
            throw new RuntimeException(e);
        }
    }
    // END Android-added: Method to clone standard file descriptors.

    // BEGIN Android-added: Methods to enable ownership enforcement of Unix file descriptors.
    /**
     * Returns the owner ID of this FileDescriptor. It's highly unlikely you should be calling this.
     * Please discuss your needs with a libcore maintainer before using this method.
     * @hide internal use only
     */
    public long getOwnerId$() {
        return this.ownerId;
    }

    /**
     * Sets the owner ID of this FileDescriptor. The owner ID does not need to be unique, but it is
     * assumed that clashes are rare. See bionic/include/android/fdsan.h for more details.
     *
     * It's highly unlikely you should be calling this.
     * Please discuss your needs with a libcore maintainer before using this method.
     * @param newOwnerId the owner ID of the Object that is responsible for closing this FileDescriptor
     * @hide internal use only
     */
    public void setOwnerId$(long newOwnerId) {
        this.ownerId = newOwnerId;
    }

    /**
     * Returns a copy of this FileDescriptor, and sets this to an invalid state.
     *
     * The returned instance is not necessarily {@code valid()}, if the original FileDescriptor
     * was invalid, or if another thread concurrently calls {@code release$()}.
     *
     * @hide internal use only
     */
    public FileDescriptor release$() {
      FileDescriptor result = new FileDescriptor();
      synchronized (releaseLock) {
          result.descriptor = this.descriptor;
          result.ownerId = this.ownerId;
          this.descriptor = -1;
          this.ownerId = FileDescriptor.NO_OWNER;
      }

      return result;
    }
    // END Android-added: Methods to enable ownership enforcement of Unix file descriptors.

    // Android-added: Needed for framework to test if it's a socket.
    /**
     * @hide internal use only
     */
    public boolean isSocket$() {
        return isSocket(descriptor);
    }

    @CriticalNative
    private static native boolean isSocket(int descriptor);
    // Set up JavaIOFileDescriptorAccess in SharedSecrets
    static {
        jdk.internal.access.SharedSecrets.setJavaIOFileDescriptorAccess(
            new jdk.internal.access.JavaIOFileDescriptorAccess() {
                public void set(FileDescriptor obj, int fd) {
                    obj.descriptor = fd;
                }

                public int get(FileDescriptor obj) {
                    return obj.descriptor;
                }

                @Override
                public boolean getAppend(FileDescriptor fdo) {
                    return fdo.append;
                }

                public void setHandle(FileDescriptor obj, long handle) {
                    throw new UnsupportedOperationException();
                }

                public long getHandle(FileDescriptor obj) {
                    throw new UnsupportedOperationException();
                }
            }
        );
    }
// Android-removed: Removed method required for parents reference counting.
}