/*

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

 */

#define _WIN32_WINNT 0x0500

#define WINVER 0x0500

#include "stdafx.h"

#include <shlobj.h>

#include <atlbase.h>

#include <locale.h>

CComModule _Module;

#include <atlwin.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "Windows.h"

#include "WinNT.h"

#include <shellapi.h>

#include "DownloadDialog.h"

#include "DownloadHelper.h"

#include "kernel.h"

#include "sun_jkernel_DownloadManager.h"

#include "sun_jkernel_Bundle.h"

#include "sun_jkernel_Mutex.h"

#include "sun_jkernel_BackgroundDownloader.h"

#include <stdio.h>

#include <windows.h>

#include <conio.h>

#include <tchar.h>

#include <tchar.h>

#include <sddl.h>

#include <Aclapi.h>

#include <strsafe.h>

BOOL IsPlatformWindowsVista();

#define BUFSIZE 4096

#define JBROKERPIPE           "\\\\.\\pipe\\jbrokerpipe"

#define JREMAINKEY              "SOFTWARE\\JavaSoft\\Java Runtime Environment"

#define JRE_VERSION_REGISTRY_KEY    JREMAINKEY "\\" VERSION

#define ReleaseAndClose(mutex) \

        if (mutex != NULL) { \

            ReleaseMutex(mutex);  \

            CloseHandle(mutex); \

            mutex = NULL; \

        }

#define KERNEL_DEBUG false

// used to inform kernel that we believe it is running in high integrity

#define JBROKER_KEY "-Dkernel.spawned.from.jbroker=true -Dkernel.background.download=false"

// this is only available on Vista SDK, hard code it here for now

#define LABEL_SECURITY_INFORMATION (0x00000010L)

// The LABEL_SECURITY_INFORMATION SDDL SACL to be set for low integrity

LPCSTR LOW_INTEGRITY_SDDL_SACL = "S:(ML;;NW;;;LW)";

CDownloadDialog dlg;

BOOL createDialog = TRUE;

CComAutoCriticalSection m_csCreateDialog;

typedef BOOL (WINAPI *LPFNInitializeSecurityDescriptor)(

        PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision);

typedef BOOL (WINAPI *LPFNSetSecurityDescriptorDacl)(

        PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl,

        BOOL bDaclDefaulted);

typedef BOOL (WINAPI *LPFNConvertStringSecurityDescriptorToSecurityDescriptorA)(

        LPCSTR StringSecurityDescriptor, DWORD StringSDRevision,

        PSECURITY_DESCRIPTOR* SecurityDescriptor,

        PULONG SecurityDescriptorSize);

typedef BOOL (WINAPI *LPFNGetSecurityDescriptorSacl)(

        PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent,

        PACL* pSacl, LPBOOL lpbSaclDefaulted);

typedef DWORD (WINAPI *LPFNSetSecurityInfo)(HANDLE handle,

        SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,

        PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl);

BOOL APIENTRY DllMain( HANDLE hModule,

                       DWORD  ul_reason_for_call,

                       LPVOID lpReserved

                     )

{

    return TRUE;

}

char* getStringPlatformChars(JNIEnv* env, jstring jstr) {

    char *result = NULL;

    size_t len;

    const jchar* utf16 = env->GetStringChars(jstr, NULL);

    len = wcstombs(NULL, utf16, env->GetStringLength(jstr) * 4) + 1;

    if (len == -1)

        return NULL;

    result = (char*) malloc(len);

    if (wcstombs(result, utf16, len) == -1)

        return NULL;

    env->ReleaseStringChars(jstr, utf16);

    return result;

}

bool SetObjectToLowIntegrity ( HANDLE hObject,

        SE_OBJECT_TYPE type = SE_KERNEL_OBJECT ) {

    bool bRet = false;

    DWORD dwErr = ERROR_SUCCESS;

    PSECURITY_DESCRIPTOR pSD = NULL;

    PACL pSacl = NULL;

    BOOL fSaclPresent = FALSE;

    BOOL fSaclDefaulted = FALSE;

    // initialize function pointers

    HMODULE hModule = LoadLibrary("Advapi32.dll");

    // ConvertStringSecurityDescriptorToSecurityDescriptorA

    LPFNConvertStringSecurityDescriptorToSecurityDescriptorA

            lpfnConvertStringSecurityDescriptorToSecurityDescriptorA =

            (LPFNConvertStringSecurityDescriptorToSecurityDescriptorA)GetProcAddress(

            hModule,

            "ConvertStringSecurityDescriptorToSecurityDescriptorA");

    // GetSecurityDescriptorSacl

    LPFNGetSecurityDescriptorSacl lpfnGetSecurityDescriptorSacl =

            (LPFNGetSecurityDescriptorSacl)GetProcAddress(hModule,

            "GetSecurityDescriptorSacl");

    // SetSecurityInfo

    LPFNSetSecurityInfo lpfnSetSecurityInfo =

            (LPFNSetSecurityInfo)GetProcAddress(hModule,

            "SetSecurityInfo");

    if (lpfnConvertStringSecurityDescriptorToSecurityDescriptorA == NULL ||

            lpfnGetSecurityDescriptorSacl == NULL ||

            lpfnSetSecurityInfo == NULL) {

        if (KERNEL_DEBUG) {

            printf("Fail to initialize function pointer\n");

        }

        FreeLibrary(hModule);

        return FALSE;

    }

    // Set object to lower integrity

    if ( lpfnConvertStringSecurityDescriptorToSecurityDescriptorA(

            LOW_INTEGRITY_SDDL_SACL, SDDL_REVISION_1, &pSD, NULL ) ) {

        if ( lpfnGetSecurityDescriptorSacl(

                pSD, &fSaclPresent, &pSacl, &fSaclDefaulted ) ) {

            dwErr = lpfnSetSecurityInfo(

                    hObject, type, LABEL_SECURITY_INFORMATION,

                    NULL, NULL, NULL, pSacl );

            bRet = (ERROR_SUCCESS == dwErr);

        }

        LocalFree( pSD );

    }

    FreeLibrary(hModule);

    return bRet;

}

JNIEXPORT jlong JNICALL Java_sun_jkernel_Mutex_createNativeMutex

                                (JNIEnv *env , jclass cls, jstring id) {

    SECURITY_ATTRIBUTES sa;

    PSECURITY_DESCRIPTOR pSD = NULL;

    BOOL saInitialized = FALSE;

    // initialize function pointers

    HMODULE hModule = LoadLibrary("Advapi32.dll");

    // InitializeSecurityDescriptor

    LPFNInitializeSecurityDescriptor lpfnInitializeSecurityDescriptor =

            (LPFNInitializeSecurityDescriptor)GetProcAddress(hModule,

            "InitializeSecurityDescriptor");

    // SetSecurityDescriptorDacl

    LPFNSetSecurityDescriptorDacl lpfnSetSecurityDescriptorDacl =

            (LPFNSetSecurityDescriptorDacl)GetProcAddress(hModule,

            "SetSecurityDescriptorDacl");

    if (lpfnInitializeSecurityDescriptor != NULL &&

            lpfnSetSecurityDescriptorDacl != NULL) {

        // Initialize a security descriptor.

        pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR,

                SECURITY_DESCRIPTOR_MIN_LENGTH);

        if (NULL == pSD) {

            if (KERNEL_DEBUG) {

                printf("LocalAlloc Error %u\n", GetLastError());

            }

            FreeLibrary(hModule);

            return NULL;

        }

        if (!lpfnInitializeSecurityDescriptor(pSD,

                SECURITY_DESCRIPTOR_REVISION)) {

            if (KERNEL_DEBUG) {

                printf("InitializeSecurityDescriptor Error %u\n", GetLastError());

            }

            FreeLibrary(hModule);

            return NULL;

        }

        // Add the ACL to the security descriptor.

        if (!lpfnSetSecurityDescriptorDacl(pSD,

                TRUE,     // bDaclPresent flag

                NULL,     // NULL DACL is assigned to the security descriptor,

                // which allows all access to the object.

                // This is to allow the mutex to be accessbile by

                // all users;  The background downloader launched

                // by the installer will be running as SYSTEM user;

                // while other java process started by the current

                // user will be running as the current username.

                FALSE))   // not a default DACL

        {

            if (KERNEL_DEBUG) {

                printf("SetSecurityDescriptorDacl Error %u\n",

                        GetLastError());

            }

            FreeLibrary(hModule);

            return NULL;

        }

        // Initialize a security attributes structure.

        sa.nLength = sizeof (SECURITY_ATTRIBUTES);

        sa.lpSecurityDescriptor = pSD;

        sa.bInheritHandle = FALSE;

        saInitialized = TRUE;

        FreeLibrary(hModule);

    }

    HANDLE m = CreateMutex(saInitialized ? &sa : NULL, FALSE,

            (LPCSTR) getStringPlatformChars(env, id));

    if (m == NULL) {

        if (KERNEL_DEBUG) {

            printf("CreateMutex Error %u\n", GetLastError());

        }

    }

    // set the mutex object to low integrity on vista, so the mutex

    // can be accessed by different integrity level

    if (IsPlatformWindowsVista()) {

        if (!SetObjectToLowIntegrity(m)) {

            if (KERNEL_DEBUG) {

                printf("Fail to set Mutex object to low integrity\n");

            }

        }

    }

    return (jlong)m ;

}

HANDLE getMutexHandle(JNIEnv *env, jobject mutex) {

    jfieldID handle = env->GetFieldID(env->GetObjectClass(mutex), "handle", "J");

    return (HANDLE) env->GetLongField(mutex, handle);

}

JNIEXPORT jboolean JNICALL Java_sun_jkernel_Mutex_acquire__I

                                (JNIEnv *env, jobject mutex, jint timeout) {

    HANDLE hmutex = getMutexHandle(env, mutex);

    if (hmutex != NULL) {

        int result = WaitForSingleObject(hmutex, timeout);

        if (result == WAIT_ABANDONED)

            result = WaitForSingleObject(hmutex, timeout);

        return (result == WAIT_OBJECT_0);

    }

    else

        return false;

}

void ThrowByName(JNIEnv *env, const char *name, const char *msg) {

    jclass cls = env->FindClass(name);

    /* if cls is NULL, an exception has already been thrown */

    if (cls != NULL) {

        env->ThrowNew(cls, msg);

    }

    /* free the local ref */

    env->DeleteLocalRef(cls);

}

JNIEXPORT void JNICALL Java_sun_jkernel_Mutex_acquire__

        (JNIEnv *env, jobject mutex) {

    if (!Java_sun_jkernel_Mutex_acquire__I(env, mutex, INFINITE)) {

        // failed to acquire mutex, most likely because it was already disposed

        ThrowByName(env, "java/lang/IllegalStateException",

                "error acquiring mutex");

    }

}

JNIEXPORT void JNICALL Java_sun_jkernel_Mutex_release

                                (JNIEnv *env, jobject mutex) {

    HANDLE hmutex = getMutexHandle(env, mutex);

    if (hmutex != NULL)

        ReleaseMutex(hmutex);

    else

        ThrowByName(env, "java/lang/IllegalStateException",

                "releasing disposed mutex");

}

JNIEXPORT void JNICALL Java_sun_jkernel_Mutex_destroyNativeMutex

        (JNIEnv *env, jobject mutex) {

    HANDLE hmutex = getMutexHandle(env, mutex);

    if (hmutex != NULL) {

        Java_sun_jkernel_Mutex_release(env, mutex);

        CloseHandle(hmutex);

    }

}

void createDownloadWindowProc(LPVOID lpParameter) {

    CDownloadDialog* pDlg = (CDownloadDialog *) lpParameter;

    pDlg->delayedDoModal();

    // dialog destroyed, need to create a new one next time

    createDialog = TRUE;

}

void createDownloadWindow(LPVOID lpParameter) {

    // Create a new thread for download window

    DWORD dwThreadId = NULL;

    ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) createDownloadWindowProc, lpParameter, 0, &dwThreadId);

}

JNIEXPORT void JNICALL Java_sun_jkernel_DownloadManager_bundleInstallComplete

    (JNIEnv *env, jclass dm) {

    dlg.bundleInstallComplete();

}

JNIEXPORT void JNICALL Java_sun_jkernel_DownloadManager_bundleInstallStart

    (JNIEnv *env, jclass dm) {

    dlg.bundleInstallStart();

}

typedef HRESULT (WINAPI *LPFNIEIsProtectedModeProcess)(BOOL *pbResult);

BOOL isRunningIEProtectedMode() {

    HMODULE hModule = NULL;

    LPFNIEIsProtectedModeProcess lpfnIEIsProtectedModeProcess;

    __try {

        hModule = LoadLibrary("ieframe.dll");

        if (hModule != NULL) {

            lpfnIEIsProtectedModeProcess = (LPFNIEIsProtectedModeProcess)

                GetProcAddress(hModule, "IEIsProtectedModeProcess");

            if (lpfnIEIsProtectedModeProcess != NULL) {

                BOOL bProtectedMode = FALSE;

                HRESULT hr = lpfnIEIsProtectedModeProcess(&bProtectedMode);

                if ( SUCCEEDED(hr) && bProtectedMode ) {

                    // IE is running in protected mode

                    return TRUE;

                } else {

                    // IE isn't running in protected mode

                    return FALSE;

                }

            }

        }

    } __finally {

        if (hModule != NULL) {

            FreeLibrary(hModule);

        }

    }

    return FALSE;

}

/* Return TRUE if current running platform is Windows Vista, FALSE otherwise */

BOOL IsPlatformWindowsVista() {

    static BOOL initialized = FALSE;

    static BOOL isVista = FALSE;

    OSVERSIONINFO  osvi;

    if (initialized) {

        return isVista;

    }

    // Initialize the OSVERSIONINFO structure.

    ZeroMemory( &osvi, sizeof( osvi ) );

    osvi.dwOSVersionInfoSize = sizeof( osvi );

    GetVersionEx( &osvi );  // Assume this function succeeds.

    if ( osvi.dwPlatformId == VER_PLATFORM_WIN32_NT &&

        osvi.dwMajorVersion == 6 ) {

        isVista = TRUE;

    } else {

        isVista = FALSE;

    }

    initialized = TRUE;

    return isVista;

}

JNIEXPORT jboolean  JNICALL Java_sun_jkernel_DownloadManager_isIEProtectedMode

    (JNIEnv *env, jclass dm) {

    if (isRunningIEProtectedMode()) {

        return TRUE;

    }

    return FALSE;

}

JNIEXPORT jboolean JNICALL Java_sun_jkernel_DownloadManager_isWindowsVista

    (JNIEnv *env, jclass dm) {

    if (IsPlatformWindowsVista()) {

        return TRUE;

    }

    return FALSE;

}

int sendMessageToBroker(const char * message) {

        char ackString[1024];

        HANDLE hp = INVALID_HANDLE_VALUE;

        while (hp == INVALID_HANDLE_VALUE) {

            hp = CreateNamedPipe(_T(JBROKERPIPE),

                    PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE ,

                    PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,

                    1, // number of pipes that can exist

                    1024, // output buffer

                    1024, // input buffer

                    0, // timeout

                    NULL); // security attributes

            if (hp == INVALID_HANDLE_VALUE) {

                DWORD err = GetLastError();

                // we only allow one instance of the pipe; if the instance

                // already exists, we will get ERROR_ACCESS_DENIED, which means

                // some other process is using the pipe, so let's try again

                if (err != ERROR_ACCESS_DENIED && err != ERROR_PIPE_BUSY) {

                    // create pipe failed

                    return 0;

                }

                // pipe instance might be in use, keep trying

            }

        }

        // Wait for the client to connect; if it succeeds,

        // the function returns a nonzero value. If the function

        // returns zero, GetLastError returns ERROR_PIPE_CONNECTED.

        BOOL fConnected = ConnectNamedPipe(hp, NULL) ?

                TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);

        if (fConnected)

        {

                // Send message to the pipe server.

                DWORD cbWritten;

                BOOL fSuccess = WriteFile(

                        hp,                  // pipe handle

                        message,             // message

                        (strlen(message)+1)*sizeof(char), // message length

                        &cbWritten,             // bytes written

                        NULL);                  // not overlapped

                if (!fSuccess)

                {

                        // WriteFile failed

                        CloseHandle(hp);

                        return 0;

                }

                // wait for ack from server

                DWORD cbRead;

                TCHAR chBuf[BUFSIZE];

                do

                {

                        // Read from the pipe.

                        fSuccess = ReadFile(

                                hp,    // pipe handle

                                chBuf,    // buffer to receive reply

                                BUFSIZE*sizeof(TCHAR),  // size of buffer

                                &cbRead,  // number of bytes read

                                NULL);    // not overlapped

                        if (! fSuccess && GetLastError() != ERROR_MORE_DATA)

                                break;

                        sprintf(ackString, "%s", chBuf);

                } while (!fSuccess);  // repeat loop if ERROR_MORE_DATA

        }

        CloseHandle(hp);

        if (strcmp(ackString, "SUCCESS") == 0) {

                // server completed move command successfully

                return 1;

        }

        return 0;

}

int sendMoveMessageToBroker(const char * fromPath, const char * userHome) {