/*

 * 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.

 */

#ifndef _WIN32_WINNT

#define _WIN32_WINNT 0x0500

#endif

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <direct.h>

#include <malloc.h>

#include <io.h>

#include <windows.h>

#include <aclapi.h>

#include <winioctl.h>

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "sun_nio_fs_WindowsNativeDispatcher.h"

/**

 * jfieldIDs

 */

static jfieldID findFirst_handle;

static jfieldID findFirst_name;

static jfieldID findFirst_attributes;

static jfieldID findStream_handle;

static jfieldID findStream_name;

static jfieldID volumeInfo_fsName;

static jfieldID volumeInfo_volName;

static jfieldID volumeInfo_volSN;

static jfieldID volumeInfo_flags;

static jfieldID diskSpace_bytesAvailable;

static jfieldID diskSpace_totalBytes;

static jfieldID diskSpace_totalFree;

static jfieldID account_domain;

static jfieldID account_name;

static jfieldID account_use;

static jfieldID aclInfo_aceCount;

static jfieldID completionStatus_error;

static jfieldID completionStatus_bytesTransferred;

static jfieldID completionStatus_completionKey;

static jfieldID backupResult_bytesTransferred;

static jfieldID backupResult_context;

/**

 * Win32 APIs not defined in Visual Studio 2003 header files

 */

typedef enum {

  FindStreamInfoStandard

} MY_STREAM_INFO_LEVELS;

typedef struct _MY_WIN32_FIND_STREAM_DATA {

  LARGE_INTEGER StreamSize;

  WCHAR cStreamName[MAX_PATH + 36];

} MY_WIN32_FIND_STREAM_DATA;

typedef HANDLE (WINAPI* FindFirstStream_Proc)(LPCWSTR, MY_STREAM_INFO_LEVELS, LPVOID, DWORD);

typedef BOOL (WINAPI* FindNextStream_Proc)(HANDLE, LPVOID);

typedef BOOLEAN (WINAPI* CreateSymbolicLinkProc) (LPCWSTR, LPCWSTR, DWORD);

typedef BOOL (WINAPI* CreateHardLinkProc) (LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);

typedef BOOL (WINAPI* GetFinalPathNameByHandleProc) (HANDLE, LPWSTR, DWORD, DWORD);

typedef BOOL (WINAPI* ConvertSidToStringSidProc) (PSID, LPWSTR*);

typedef BOOL (WINAPI* ConvertStringSidToSidProc) (LPWSTR, PSID*);

typedef DWORD (WINAPI* GetLengthSidProc) (PSID);

static FindFirstStream_Proc FindFirstStream_func;

static FindNextStream_Proc FindNextStream_func;

static CreateSymbolicLinkProc CreateSymbolicLink_func;

static CreateHardLinkProc CreateHardLink_func;

static GetFinalPathNameByHandleProc GetFinalPathNameByHandle_func;

static ConvertSidToStringSidProc ConvertSidToStringSid_func;

static ConvertStringSidToSidProc ConvertStringSidToSid_func;

static GetLengthSidProc GetLengthSid_func;

static void throwWindowsException(JNIEnv* env, DWORD lastError) {

    jobject x = JNU_NewObjectByName(env, "sun/nio/fs/WindowsException",

        "(I)V", lastError);

    if (x != NULL) {

        (*env)->Throw(env, x);

    }

}

/**

 * Initializes jfieldIDs and get address of Win32 calls that are located

 * at runtime.

 */

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_initIDs(JNIEnv* env, jclass this)

{

    jclass clazz;

    HMODULE h;

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$FirstFile");

    if (clazz == NULL) {

        return;

    }

    findFirst_handle = (*env)->GetFieldID(env, clazz, "handle", "J");

    findFirst_name = (*env)->GetFieldID(env, clazz, "name", "Ljava/lang/String;");

    findFirst_attributes = (*env)->GetFieldID(env, clazz, "attributes", "I");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$FirstStream");

    if (clazz == NULL) {

        return;

    }

    findStream_handle = (*env)->GetFieldID(env, clazz, "handle", "J");

    findStream_name = (*env)->GetFieldID(env, clazz, "name", "Ljava/lang/String;");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$VolumeInformation");

    if (clazz == NULL) {

        return;

    }

    volumeInfo_fsName = (*env)->GetFieldID(env, clazz, "fileSystemName", "Ljava/lang/String;");

    volumeInfo_volName = (*env)->GetFieldID(env, clazz, "volumeName", "Ljava/lang/String;");

    volumeInfo_volSN = (*env)->GetFieldID(env, clazz, "volumeSerialNumber", "I");

    volumeInfo_flags = (*env)->GetFieldID(env, clazz, "flags", "I");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$DiskFreeSpace");

    if (clazz == NULL) {

        return;

    }

    diskSpace_bytesAvailable = (*env)->GetFieldID(env, clazz, "freeBytesAvailable", "J");

    diskSpace_totalBytes = (*env)->GetFieldID(env, clazz, "totalNumberOfBytes", "J");

    diskSpace_totalFree = (*env)->GetFieldID(env, clazz, "totalNumberOfFreeBytes", "J");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$Account");

    if (clazz == NULL) {

        return;

    }

    account_domain = (*env)->GetFieldID(env, clazz, "domain", "Ljava/lang/String;");

    account_name = (*env)->GetFieldID(env, clazz, "name", "Ljava/lang/String;");

    account_use = (*env)->GetFieldID(env, clazz, "use", "I");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$AclInformation");

    if (clazz == NULL) {

        return;

    }

    aclInfo_aceCount = (*env)->GetFieldID(env, clazz, "aceCount", "I");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$CompletionStatus");

    if (clazz == NULL) {

        return;

    }

    completionStatus_error = (*env)->GetFieldID(env, clazz, "error", "I");

    completionStatus_bytesTransferred = (*env)->GetFieldID(env, clazz, "bytesTransferred", "I");

    completionStatus_completionKey = (*env)->GetFieldID(env, clazz, "completionKey", "I");

    clazz = (*env)->FindClass(env, "sun/nio/fs/WindowsNativeDispatcher$BackupResult");

    if (clazz == NULL) {

        return;

    }

    backupResult_bytesTransferred = (*env)->GetFieldID(env, clazz, "bytesTransferred", "I");

    backupResult_context = (*env)->GetFieldID(env, clazz, "context", "J");

    h = LoadLibrary("kernel32");

    if (h != INVALID_HANDLE_VALUE) {

        FindFirstStream_func =

            (FindFirstStream_Proc)GetProcAddress(h, "FindFirstStreamW");

        FindNextStream_func =

            (FindNextStream_Proc)GetProcAddress(h, "FindNextStreamW");

        CreateSymbolicLink_func =

            (CreateSymbolicLinkProc)GetProcAddress(h, "CreateSymbolicLinkW");

        CreateHardLink_func =

            (CreateHardLinkProc)GetProcAddress(h, "CreateHardLinkW");

        GetFinalPathNameByHandle_func =

            (GetFinalPathNameByHandleProc)GetProcAddress(h, "GetFinalPathNameByHandleW");

        FreeLibrary(h);

    }

    h = LoadLibrary("advapi32");

    if (h != INVALID_HANDLE_VALUE) {

        ConvertSidToStringSid_func =

            (ConvertSidToStringSidProc)GetProcAddress(h, "ConvertSidToStringSidW");

        ConvertStringSidToSid_func =

            (ConvertStringSidToSidProc)GetProcAddress(h, "ConvertStringSidToSidW");

        GetLengthSid_func =

            (GetLengthSidProc)GetProcAddress(h, "GetLengthSid");

        FreeLibrary(h);

    }

}

JNIEXPORT jstring JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FormatMessage(JNIEnv* env, jclass this, jint errorCode) {

    WCHAR message[255];

    DWORD len = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,

                               NULL,

                               (DWORD)errorCode,

                               0,

                               &message[0],

                               255,

                               NULL);

    if (len == 0) {

        return NULL;

    } else {

        return (*env)->NewString(env, (const jchar *)message, (jsize)wcslen(message));

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_LocalFree(JNIEnv* env, jclass this, jlong address)

{

    HLOCAL hMem = (HLOCAL)jlong_to_ptr(address);

    LocalFree(hMem);

}

JNIEXPORT jlong JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_CreateFile0(JNIEnv* env, jclass this,

    jlong address, jint dwDesiredAccess, jint dwShareMode, jlong sdAddress,

    jint dwCreationDisposition, jint dwFlagsAndAttributes)

{

    HANDLE handle;

    LPCWSTR lpFileName = jlong_to_ptr(address);

    SECURITY_ATTRIBUTES securityAttributes;

    LPSECURITY_ATTRIBUTES lpSecurityAttributes;

    PSECURITY_DESCRIPTOR lpSecurityDescriptor = jlong_to_ptr(sdAddress);

    if (lpSecurityDescriptor == NULL) {

        lpSecurityAttributes = NULL;

    } else {

        securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);

        securityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;

        securityAttributes.bInheritHandle = FALSE;

        lpSecurityAttributes = &securityAttributes;

    }

    handle = CreateFileW(lpFileName,

                        (DWORD)dwDesiredAccess,

                        (DWORD)dwShareMode,

                        lpSecurityAttributes,

                        (DWORD)dwCreationDisposition,

                        (DWORD)dwFlagsAndAttributes,

                        NULL);

    if (handle == INVALID_HANDLE_VALUE) {

        throwWindowsException(env, GetLastError());

    }

    return ptr_to_jlong(handle);

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_DeviceIoControlSetSparse(JNIEnv* env, jclass this,

    jlong handle)

{

    DWORD bytesReturned;

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    if (DeviceIoControl(h, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, &bytesReturned, NULL) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_DeviceIoControlGetReparsePoint(JNIEnv* env, jclass this,

    jlong handle, jlong bufferAddress, jint bufferSize)

{

    DWORD bytesReturned;

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    LPVOID outBuffer = (LPVOID)jlong_to_ptr(bufferAddress);

    if (DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, NULL, 0, outBuffer, (DWORD)bufferSize,

                        &bytesReturned, NULL) == 0)

    {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_DeleteFile0(JNIEnv* env, jclass this, jlong address)

{

    LPCWSTR lpFileName = jlong_to_ptr(address);

    if (DeleteFileW(lpFileName) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_CreateDirectory0(JNIEnv* env, jclass this,

    jlong address, jlong sdAddress)

{

    LPCWSTR lpFileName = jlong_to_ptr(address);

    SECURITY_ATTRIBUTES securityAttributes;

    LPSECURITY_ATTRIBUTES lpSecurityAttributes;

    PSECURITY_DESCRIPTOR lpSecurityDescriptor = jlong_to_ptr(sdAddress);

    if (lpSecurityDescriptor == NULL) {

        lpSecurityAttributes = NULL;

    } else {

        securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);

        securityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;

        securityAttributes.bInheritHandle = FALSE;

        lpSecurityAttributes = &securityAttributes;

    }

    if (CreateDirectoryW(lpFileName, lpSecurityAttributes) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_RemoveDirectory0(JNIEnv* env, jclass this, jlong address)

{

    LPCWSTR lpFileName = jlong_to_ptr(address);

    if (RemoveDirectoryW(lpFileName) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_CloseHandle(JNIEnv* env, jclass this,

    jlong handle)

{

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    CloseHandle(h);

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindFirstFile0(JNIEnv* env, jclass this,

    jlong address, jobject obj)

{

    WIN32_FIND_DATAW data;

    LPCWSTR lpFileName = jlong_to_ptr(address);

    HANDLE handle = FindFirstFileW(lpFileName, &data);

    if (handle != INVALID_HANDLE_VALUE) {

        jstring name = (*env)->NewString(env, data.cFileName, (jsize)wcslen(data.cFileName));

        if (name == NULL)

            return;

        (*env)->SetLongField(env, obj, findFirst_handle, ptr_to_jlong(handle));

        (*env)->SetObjectField(env, obj, findFirst_name, name);

        (*env)->SetIntField(env, obj, findFirst_attributes, data.dwFileAttributes);

    } else {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT jlong JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindFirstFile1(JNIEnv* env, jclass this,

    jlong pathAddress, jlong dataAddress)

{

    LPCWSTR lpFileName = jlong_to_ptr(pathAddress);

    WIN32_FIND_DATAW* data = (WIN32_FIND_DATAW*)jlong_to_ptr(dataAddress);

    HANDLE handle = FindFirstFileW(lpFileName, data);

    if (handle == INVALID_HANDLE_VALUE) {

        throwWindowsException(env, GetLastError());

    }

    return ptr_to_jlong(handle);

}

JNIEXPORT jstring JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindNextFile(JNIEnv* env, jclass this,

    jlong handle, jlong dataAddress)

{

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    WIN32_FIND_DATAW* data = (WIN32_FIND_DATAW*)jlong_to_ptr(dataAddress);

    if (FindNextFileW(h, data) != 0) {

        return (*env)->NewString(env, data->cFileName, (jsize)wcslen(data->cFileName));

    } else {

    if (GetLastError() != ERROR_NO_MORE_FILES)

        throwWindowsException(env, GetLastError());

        return NULL;

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindFirstStream0(JNIEnv* env, jclass this,

    jlong address, jobject obj)

{

    MY_WIN32_FIND_STREAM_DATA data;

    LPCWSTR lpFileName = jlong_to_ptr(address);

    HANDLE handle;

    if (FindFirstStream_func == NULL) {

        JNU_ThrowInternalError(env, "Should not get here");

        return;

    }

    handle = (*FindFirstStream_func)(lpFileName, FindStreamInfoStandard, &data, 0);

    if (handle != INVALID_HANDLE_VALUE) {

        jstring name = (*env)->NewString(env, data.cStreamName, (jsize)wcslen(data.cStreamName));

        if (name == NULL)

            return;

        (*env)->SetLongField(env, obj, findStream_handle, ptr_to_jlong(handle));

        (*env)->SetObjectField(env, obj, findStream_name, name);

    } else {

        if (GetLastError() == ERROR_HANDLE_EOF) {

             (*env)->SetLongField(env, obj, findStream_handle, ptr_to_jlong(handle));

        } else {

            throwWindowsException(env, GetLastError());

        }

    }

}

JNIEXPORT jstring JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindNextStream(JNIEnv* env, jclass this,

    jlong handle)

{

    MY_WIN32_FIND_STREAM_DATA data;

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    if (FindNextStream_func == NULL) {

        JNU_ThrowInternalError(env, "Should not get here");

        return NULL;

    }

    if ((*FindNextStream_func)(h, &data) != 0) {

        return (*env)->NewString(env, data.cStreamName, (jsize)wcslen(data.cStreamName));

    } else {

        if (GetLastError() != ERROR_HANDLE_EOF)

            throwWindowsException(env, GetLastError());

        return NULL;

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_FindClose(JNIEnv* env, jclass this,

    jlong handle)

{

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    if (FindClose(h) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_GetFileInformationByHandle(JNIEnv* env, jclass this,

    jlong handle, jlong address)

{

    HANDLE h = (HANDLE)jlong_to_ptr(handle);

    BY_HANDLE_FILE_INFORMATION* info =

        (BY_HANDLE_FILE_INFORMATION*)jlong_to_ptr(address);

    if (GetFileInformationByHandle(h, info) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_CopyFileEx0(JNIEnv* env, jclass this,

    jlong existingAddress, jlong newAddress, jint flags, jlong cancelAddress)

{

    LPCWSTR lpExistingFileName = jlong_to_ptr(existingAddress);

    LPCWSTR lpNewFileName = jlong_to_ptr(newAddress);

    LPBOOL cancel = (LPBOOL)jlong_to_ptr(cancelAddress);

    if (CopyFileExW(lpExistingFileName, lpNewFileName, NULL, NULL, cancel,

                    (DWORD)flags) == 0)

    {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_MoveFileEx0(JNIEnv* env, jclass this,

    jlong existingAddress, jlong newAddress, jint flags)

{

    LPCWSTR lpExistingFileName = jlong_to_ptr(existingAddress);

    LPCWSTR lpNewFileName = jlong_to_ptr(newAddress);

    if (MoveFileExW(lpExistingFileName, lpNewFileName, (DWORD)flags) == 0) {

        throwWindowsException(env, GetLastError());

    }

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_GetLogicalDrives(JNIEnv* env, jclass this)

{

    DWORD res = GetLogicalDrives();

    if (res == 0) {

        throwWindowsException(env, GetLastError());

    }

    return (jint)res;

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_WindowsNativeDispatcher_GetFileAttributes0(JNIEnv* env, jclass this,

    jlong address)