/*

 * Copyright 2008-2009 Sun Microsystems, Inc.  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.  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.fs;

import java.security.AccessController;

import java.security.PrivilegedAction;

import sun.misc.Unsafe;

/**

 * Win32 and library calls.

 */

class WindowsNativeDispatcher {

    private WindowsNativeDispatcher() { }

    /**

     * HANDLE CreateFile(

     *   LPCTSTR lpFileName,

     *   DWORD dwDesiredAccess,

     *   DWORD dwShareMode,

     *   LPSECURITY_ATTRIBUTES lpSecurityAttributes,

     *   DWORD dwCreationDisposition,

     *   DWORD dwFlagsAndAttributes,

     *   HANDLE hTemplateFile

     * )

     */

    static long CreateFile(String path,

                           int dwDesiredAccess,

                           int dwShareMode,

                           long lpSecurityAttributes,

                           int dwCreationDisposition,

                           int dwFlagsAndAttributes)

        throws WindowsException

    {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            return CreateFile0(buffer.address(),

                               dwDesiredAccess,

                               dwShareMode,

                               lpSecurityAttributes,

                               dwCreationDisposition,

                               dwFlagsAndAttributes);

        } finally {

            buffer.release();

        }

    }

    static long CreateFile(String path,

                           int dwDesiredAccess,

                           int dwShareMode,

                           int dwCreationDisposition,

                           int dwFlagsAndAttributes)

        throws WindowsException

    {

        return CreateFile(path, dwDesiredAccess, dwShareMode, 0L,

                          dwCreationDisposition, dwFlagsAndAttributes);

    }

    private static native long CreateFile0(long lpFileName,

                                           int dwDesiredAccess,

                                           int dwShareMode,

                                           long lpSecurityAttributes,

                                           int dwCreationDisposition,

                                           int dwFlagsAndAttributes)

        throws WindowsException;

    /**

     * CloseHandle(

     *   HANDLE hObject

     * )

     */

    static native void CloseHandle(long handle);

    /**

     * DeleteFile(

     *   LPCTSTR lpFileName

     * )

     */

    static void DeleteFile(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            DeleteFile0(buffer.address());

        } finally {

            buffer.release();

        }

    }

    private static native void DeleteFile0(long lpFileName)

        throws WindowsException;

    /**

     * CreateDirectory(

     *   LPCTSTR lpPathName,

     *   LPSECURITY_ATTRIBUTES lpSecurityAttributes

     * )

     */

    static void CreateDirectory(String path, long lpSecurityAttributes) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            CreateDirectory0(buffer.address(), lpSecurityAttributes);

        } finally {

            buffer.release();

        }

    }

    private static native void CreateDirectory0(long lpFileName, long lpSecurityAttributes)

        throws WindowsException;

    /**

     * RemoveDirectory(

     *   LPCTSTR lpPathName

     * )

     */

    static void RemoveDirectory(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            RemoveDirectory0(buffer.address());

        } finally {

            buffer.release();

        }

    }

    private static native void RemoveDirectory0(long lpFileName)

        throws WindowsException;

    /**

     * Marks a file as a sparse file.

     *

     * DeviceIoControl(

     *   FSCTL_SET_SPARSE

     * )

     */

    static native void DeviceIoControlSetSparse(long handle)

        throws WindowsException;

    /**

     * Retrieves the reparse point data associated with the file or directory.

     *

     * DeviceIoControl(

     *   FSCTL_GET_REPARSE_POINT

     * )

     */

    static native void DeviceIoControlGetReparsePoint(long handle,

        long bufferAddress, int bufferSize) throws WindowsException;

    /**

     * HANDLE FindFirstFile(

     *   LPCTSTR lpFileName,

     *   LPWIN32_FIND_DATA lpFindFileData

     * )

     */

    static FirstFile FindFirstFile(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            FirstFile data = new FirstFile();

            FindFirstFile0(buffer.address(), data);

            return data;

        } finally {

            buffer.release();

        }

    }

    static class FirstFile {

        private long handle;

        private String name;

        private FirstFile() { }

        public long handle()    { return handle; }

        public String name()    { return name; }

    }

    private static native void FindFirstFile0(long lpFileName, FirstFile obj)

        throws WindowsException;

    /**

     * HANDLE FindFirstFile(

     *   LPCTSTR lpFileName,

     *   LPWIN32_FIND_DATA lpFindFileData

     * )

     */

    static long FindFirstFile(String path, long address) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            return FindFirstFile1(buffer.address(), address);

        } finally {

            buffer.release();

        }

    }

    private static native long FindFirstFile1(long lpFileName, long address)

        throws WindowsException;

    /**

     * FindNextFile(

     *   HANDLE hFindFile,

     *   LPWIN32_FIND_DATA lpFindFileData

     * )

     *

     * @return  lpFindFileData->cFileName

     */

    static native String FindNextFile(long handle) throws WindowsException;

    /**

     * HANDLE FindFirstStreamW(

     *   LPCWSTR lpFileName,

     *   STREAM_INFO_LEVELS InfoLevel,

     *   LPVOID lpFindStreamData,

     *   DWORD dwFlags

     * )

     */

    static FirstStream FindFirstStream(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            FirstStream data = new FirstStream();

            FindFirstStream0(buffer.address(), data);

            if (data.handle() == WindowsConstants.INVALID_HANDLE_VALUE)

                return null;

            return data;

        } finally {

            buffer.release();

        }

    }

    static class FirstStream {

        private long handle;

        private String name;

        private FirstStream() { }

        public long handle()    { return handle; }

        public String name()    { return name; }

    }

    private static native void FindFirstStream0(long lpFileName, FirstStream obj)

        throws WindowsException;

    /*

     * FindNextStreamW(

     *   HANDLE hFindStream,

     *   LPVOID lpFindStreamData

     * )

     */

    static native String FindNextStream(long handle) throws WindowsException;

    /**

     * FindClose(

     *   HANDLE hFindFile

     * )

     */

    static native void FindClose(long handle) throws WindowsException;

    /**

     * GetFileInformationByHandle(

     *   HANDLE hFile,

     *   LPBY_HANDLE_FILE_INFORMATION lpFileInformation

     * )

     */

    static native void GetFileInformationByHandle(long handle, long address)

        throws WindowsException;

    /**

     * CopyFileEx(

     *   LPCWSTR lpExistingFileName

     *   LPCWSTR lpNewFileName,

     *   LPPROGRESS_ROUTINE lpProgressRoutine

     *   LPVOID lpData,

     *   LPBOOL pbCancel,

     *   DWORD dwCopyFlags

     * )

     */

    static void CopyFileEx(String source, String target, int flags,

                           long addressToPollForCancel)

        throws WindowsException

    {

        NativeBuffer sourceBuffer = asNativeBuffer(source);

        NativeBuffer targetBuffer = asNativeBuffer(target);

        try {

            CopyFileEx0(sourceBuffer.address(), targetBuffer.address(), flags,

                        addressToPollForCancel);

        } finally {

            targetBuffer.release();

            sourceBuffer.release();

        }

    }

    private static native void CopyFileEx0(long existingAddress, long newAddress,

        int flags, long addressToPollForCancel) throws WindowsException;

    /**

     * MoveFileEx(

     *   LPCTSTR lpExistingFileName,

     *   LPCTSTR lpNewFileName,

     *   DWORD dwFlags

     * )

     */

    static void MoveFileEx(String source, String target, int flags)

        throws WindowsException

    {

        NativeBuffer sourceBuffer = asNativeBuffer(source);

        NativeBuffer targetBuffer = asNativeBuffer(target);

        try {

            MoveFileEx0(sourceBuffer.address(), targetBuffer.address(), flags);

        } finally {

            targetBuffer.release();

            sourceBuffer.release();

        }

    }

    private static native void MoveFileEx0(long existingAddress, long newAddress,

        int flags) throws WindowsException;

    /**

     * DWORD GetFileAttributes(

     *   LPCTSTR lpFileName

     * )

     */

    static int GetFileAttributes(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            return GetFileAttributes0(buffer.address());

        } finally {

            buffer.release();

        }

    }

    private static native int GetFileAttributes0(long lpFileName)

        throws WindowsException;

    /**

     * SetFileAttributes(

     *   LPCTSTR lpFileName,

     *   DWORD dwFileAttributes

     */

    static void SetFileAttributes(String path, int dwFileAttributes)

        throws WindowsException

    {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            SetFileAttributes0(buffer.address(), dwFileAttributes);

        } finally {

            buffer.release();

        }

    }

    private static native void SetFileAttributes0(long lpFileName,

        int dwFileAttributes) throws WindowsException;

    /**

     * GetFileAttributesEx(

     *   LPCTSTR lpFileName,

     *   GET_FILEEX_INFO_LEVELS fInfoLevelId,

     *   LPVOID lpFileInformation

     * );

     */

    static void GetFileAttributesEx(String path, long address) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            GetFileAttributesEx0(buffer.address(), address);

        } finally {

            buffer.release();

        }

    }

    private static native void GetFileAttributesEx0(long lpFileName, long address)

        throws WindowsException;

    /**

     * SetFileTime(

     *   HANDLE hFile,

     *   CONST FILETIME *lpCreationTime,

     *   CONST FILETIME *lpLastAccessTime,

     *   CONST FILETIME *lpLastWriteTime

     * )

     */

    static native void SetFileTime(long handle, long createTime,

        long lastAccessTime, long lastWriteTime) throws WindowsException;

    /**

     * SetEndOfFile(

     *   HANDLE hFile

     * )

     */

    static native void SetEndOfFile(long handle) throws WindowsException;

    /**

     * DWORD GetLogicalDrives(VOID)

     */

    static native int GetLogicalDrives() throws WindowsException;

    /**

     * GetVolumeInformation(

     *   LPCTSTR lpRootPathName,

     *   LPTSTR lpVolumeNameBuffer,

     *   DWORD nVolumeNameSize,

     *   LPDWORD lpVolumeSerialNumber,

     *   LPDWORD lpMaximumComponentLength,

     *   LPDWORD lpFileSystemFlags,

     *   LPTSTR lpFileSystemNameBuffer,

     *   DWORD nFileSystemNameSize

     * )

     */

    static VolumeInformation GetVolumeInformation(String root)

        throws WindowsException

    {

        NativeBuffer buffer = asNativeBuffer(root);

        try {

            VolumeInformation info = new VolumeInformation();

            GetVolumeInformation0(buffer.address(), info);

            return info;

        } finally {

            buffer.release();

        }

    }

    static class VolumeInformation {

        private String fileSystemName;

        private String volumeName;

        private int volumeSerialNumber;

        private int flags;

        private VolumeInformation() { }

        public String fileSystemName()      { return fileSystemName; }

        public String volumeName()          { return volumeName; }

        public int volumeSerialNumber()     { return volumeSerialNumber; }

        public int flags()                  { return flags; }

    }

    private static native void GetVolumeInformation0(long lpRoot,

                                                     VolumeInformation obj)

        throws WindowsException;

    /**

     * UINT GetDriveType(

     *   LPCTSTR lpRootPathName

     * )

     */

    static int GetDriveType(String root) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(root);

        try {

            return GetDriveType0(buffer.address());

        } finally {

            buffer.release();

        }

    }

    private static native int GetDriveType0(long lpRoot) throws WindowsException;

    /**

     * GetDiskFreeSpaceEx(

     *   LPCTSTR lpDirectoryName,

     *   PULARGE_INTEGER lpFreeBytesAvailableToCaller,

     *   PULARGE_INTEGER lpTotalNumberOfBytes,

     *   PULARGE_INTEGER lpTotalNumberOfFreeBytes

     * )

     */

    static DiskFreeSpace GetDiskFreeSpaceEx(String path)

        throws WindowsException

    {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            DiskFreeSpace space = new DiskFreeSpace();

            GetDiskFreeSpaceEx0(buffer.address(), space);

            return space;

        } finally {

            buffer.release();

        }

    }

    static class DiskFreeSpace {

        private long freeBytesAvailable;

        private long totalNumberOfBytes;

        private long totalNumberOfFreeBytes;

        private DiskFreeSpace() { }

        public long freeBytesAvailable()      { return freeBytesAvailable; }

        public long totalNumberOfBytes()      { return totalNumberOfBytes; }

        public long totalNumberOfFreeBytes()  { return totalNumberOfFreeBytes; }

    }

    private static native void GetDiskFreeSpaceEx0(long lpDirectoryName,

                                                   DiskFreeSpace obj)

        throws WindowsException;

    /**

     * GetVolumePathName(

     *   LPCTSTR lpszFileName,

     *   LPTSTR lpszVolumePathName,

     *   DWORD cchBufferLength

     * )

     *

     * @return  lpFileName

     */

    static String GetVolumePathName(String path) throws WindowsException {

        NativeBuffer buffer = asNativeBuffer(path);

        try {

            return GetVolumePathName0(buffer.address());

        } finally {

            buffer.release();

        }

    }

    private static native String GetVolumePathName0(long lpFileName)

        throws WindowsException;

    /**

     * InitializeSecurityDescriptor(

     *   PSECURITY_DESCRIPTOR pSecurityDescriptor,

     *   DWORD dwRevision

     * )

     */

    static native void InitializeSecurityDescriptor(long sdAddress)

        throws WindowsException;

    /**

     * InitializeAcl(

     *   PACL pAcl,

     *   DWORD nAclLength,

     *   DWORD dwAclRevision

     * )

     */

    static native void InitializeAcl(long aclAddress, int size)

         throws WindowsException;

    /**

     * GetFileSecurity(

     *   LPCTSTR lpFileName,

     *   SECURITY_INFORMATION RequestedInformation,