/*

 * Copyright (c) 2005, 2016, 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.

 */

/*

 * A DLL which is loaded by Windows executables to handle communication

 * between Java VMs purposes of Accessbility.

 */

#include "AccessBridgeDebug.h"

#include "WinAccessBridge.h"

#include "accessBridgeResource.h"

#include "accessBridgeCallbacks.h"

#include "AccessBridgeMessages.h"

#include "AccessBridgeMessageQueue.h"

#include <windows.h>

#include <jni.h>

#include <stdio.h>

// send memory lock

//

// This lock is need to serialize access to the buffer used by sendMemoryPackage.

// If a JVM goes away while the associated memory buffer is in use, a thread switch

// allows a call to JavaVMDestroyed and deallocation of the memory buffer.

CRITICAL_SECTION sendMemoryIPCLock;

// registry paths to newly found JVMs that don't have the bridge installed

char **newJVMs;

WinAccessBridge *theWindowsAccessBridge;

HWND theDialogWindow;

// unique broadcast msg. IDs gotten dymanically

extern UINT theFromJavaHelloMsgID;

extern UINT theFromWindowsHelloMsgID;

// protects the javaVMs chain while in use

bool isVMInstanceChainInUse;

/* =================================================================================== */

/**

 * Proc for "New JVM Found" dialog

 */

BOOL CALLBACK newJVMFoundDialogProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) {

    switch (message) {

    case WM_COMMAND:

        // PrintDebugString("    newJVMDialogProc: LOWORD(wParam) = %d", LOWORD(wParam));

        switch (LOWORD(wParam)) {

            // Remind user later that a new JVM was installed

        case cRemindThereIsNewJVM:

            // do nothing

            EndDialog(hwndDlg, wParam);

            return TRUE;

            // Do not remind user later that a new JVM was installed

            /*

        case cDoNotRemindThereIsNewJVM:

            PrintDebugString("    newJVMDialogProc: cDoNotRemindThereIsNewJVM");

            // remember to not remind the user there are new JVMs

            PrintDebugString("theWindowsAccessBridge = %x", theWindowsAccessBridge);

            if (theWindowsAccessBridge != NULL) {

                dontRemindUser(newJVMs);

            }

            EndDialog(hwndDlg, wParam);

            return TRUE;

            */

            // Run the AccessBridge installer

            /*

        case cInstallAccessBridge:

            PrintDebugString("    newJVMDialogProc: cInstallAccessBridge");

            // start the installer

            if (theWindowsAccessBridge != NULL) {

                startInstaller(newJVMs);

            }

            EndDialog(hwndDlg, wParam);

            return TRUE;

            */

        default:

            ;

        }

    default:

        ;

    }

    return FALSE;

}

/* =========================================================================== */

// ---------------------------------------------------------------------------

extern "C" {

    /**

     * DllMain - where Windows executables will load/unload us

     *

     */

    BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) {

        switch (fdwReason) {

        case DLL_PROCESS_ATTACH:        // A Windows executable loaded us

            theWindowsAccessBridge = new WinAccessBridge(hinstDll);

            break;

        case DLL_PROCESS_DETACH:        // A Windows executable unloaded us

            if (theWindowsAccessBridge != (WinAccessBridge *) 0) {

                delete theWindowsAccessBridge;

            }

            break;

        }

        return(TRUE);

    }

    /**

     * Append debug info to dialog

     *

     * replaced with code to send output to debug file

     *

     */

    void AppendToCallInfo(char *s) {

        /*

          _CrtDbgReport(_CRT_WARN, (const char *) NULL, NULL, (const char *) NULL,

          (const char *) "WinAccessBridge: %s", s);

        */

        char buf[1024];

        sprintf(buf, "WinAccessBridge: %s", s);

        OutputDebugString(buf);

    }

    /**

     * Our window proc

     *

     */

    BOOL CALLBACK AccessBridgeDialogProc(HWND hDlg, UINT message, UINT wParam, LONG lParam) {

        COPYDATASTRUCT *sentToUs;

        char *package;

        switch (message) {

        case WM_INITDIALOG:

            break;

            // call from Java with data for us to deliver

        case WM_COPYDATA:

            if (theDialogWindow == (HWND) wParam) {

            } else {

                sentToUs = (COPYDATASTRUCT *) lParam;

                package = (char *) sentToUs->lpData;

                theWindowsAccessBridge->preProcessPackage(package, sentToUs->cbData);

            }

            break;

            // message to ourselves -> de-queue messages and send 'em

        case AB_MESSAGE_QUEUED:

            theWindowsAccessBridge->receiveAQueuedPackage();

            break;

            // a JavaAccessBridge DLL is going away

            //

            // When JavaVMDestroyed is called a AccessBridgeJavaVMInstance in the

            // javaVMs chain will be removed.  If that chain is in use this will

            // cause a crash.  One way AB_DLL_GOING_AWAY can arrive is on any

            // outgoing SendMessage call.  SendMessage normally spins waiting for

            // a response.  However, if there is an incoming SendMessage, e.g. for

            // AB_DLL_GOING_AWAY Windows will send that request to this DialogProc.

            // One seemingly easy way to combat that is to use SendMessageTimeout

            // with the SMTO_BLOCK flag set.  However, it has been the case that

            // even after using that technique AB_DLL_GOING_AWAY can still arrive

            // in the middle of processing the javaVMs chain.  An alternative that

            // was tried was to use a critical section around any access ot the

            // javaVMs chain but unfortunately the AB_DLL_GOING_AWAY message arrives

            // on the same thread and thus the use of a critical section is ineffective.

            // The solution then is to set a flag whenever the javaVMs chain is being

            // used and if that flag is set at this point the message will be posted

            // to the message queue.  That would delay the destruction of the instance

            // until the chain is not being traversed.

        case AB_DLL_GOING_AWAY:

            if (isVMInstanceChainInUse) {

                PostMessage(hDlg, AB_DLL_GOING_AWAY, wParam, (LPARAM)0);

            } else {

                theWindowsAccessBridge->JavaVMDestroyed((HWND) wParam);

            }

            break;

        default:

            // the JavaVM is saying "hi"!

            // wParam == sourceHwnd; lParam == JavaVMID

            if (message == theFromJavaHelloMsgID) {

                theWindowsAccessBridge->rendezvousWithNewJavaDLL((HWND) wParam, (long ) lParam);

            }

            break;

        }

        return (FALSE);

    }

}

// ---------------------------------------------------------------------------

/**

 * Initialize the WinAccessBridge

 *

 */

WinAccessBridge::WinAccessBridge(HINSTANCE hInstance) {

    //  IntializeCriticalSection should only be called once.

    InitializeCriticalSection(&sendMemoryIPCLock);

    windowsInstance = hInstance;

    javaVMs = (AccessBridgeJavaVMInstance *) 0;

    eventHandler = new AccessBridgeEventHandler();

    messageQueue = new AccessBridgeMessageQueue();

    initBroadcastMessageIDs();          // get the unique to us broadcast msg. IDs

    theWindowsAccessBridge = this;

    isVMInstanceChainInUse = false;

    ShowWindow(theDialogWindow, SW_SHOW);

}

/**

 * Destroy the WinAccessBridge

 *

 */

WinAccessBridge::~WinAccessBridge() {

    // inform all other AccessBridges that we're going away

    //  -> shut down all event listening

    //  -> release all objects held in the JVM by us

    // send a broadcast msg.; let other AccessBridge DLLs know we're going away

    AccessBridgeJavaVMInstance *current = javaVMs;

    while (current != (AccessBridgeJavaVMInstance *) 0) {

        SendMessage(current->javaAccessBridgeWindow,

                    AB_DLL_GOING_AWAY, (WPARAM) dialogWindow, (LPARAM) 0);

        current = current->nextJVMInstance;

    }

    delete eventHandler;

    delete messageQueue;

    delete javaVMs;

    DestroyWindow(theDialogWindow);

}

/**

 * Bring up our window; make a connection to the rest of the world

 *

 */

BOOL

WinAccessBridge::initWindow() {

    theDialogWindow = CreateDialog(windowsInstance,

                                   "ACCESSBRIDGESTATUSWINDOW", NULL,

                                   (DLGPROC) AccessBridgeDialogProc);

    // If window could not be created, return "failure".

    if (!theDialogWindow)

        return (FALSE);

    dialogWindow = theDialogWindow;

    // Make the window visible, update its client area, & return "success".

    // DEBUG_CODE(ShowWindow (theDialogWindow, SW_SHOWNORMAL));

    // DEBUG_CODE(UpdateWindow (theDialogWindow));

    // post a broadcast msg.; let other AccessBridge DLLs know we exist

    PostMessage(HWND_BROADCAST, theFromWindowsHelloMsgID, (WPARAM) dialogWindow, (LPARAM) 0);

    return (TRUE);

}

// -----------------------

/**

 * rendezvousWithNewJavaDLL

 *              - Build AccessBridgeJavaVMInstance data structure

 *                (including setting up Memory-Mapped file info)

 *

 */

LRESULT

WinAccessBridge::rendezvousWithNewJavaDLL(HWND JavaBridgeDLLwindow, long vmID) {

    LRESULT returnVal;

                     JavaBridgeDLLwindow, vmID);

    isVMInstanceChainInUse = true;

    AccessBridgeJavaVMInstance *newVM =

        new AccessBridgeJavaVMInstance(dialogWindow, JavaBridgeDLLwindow, vmID, javaVMs);

    javaVMs = newVM;

    isVMInstanceChainInUse = false;

    returnVal = javaVMs->initiateIPC();

    if (returnVal == 0) {

        // tell the newly created JavaVM what events we're interested in, if any

        long javaEventMask = eventHandler->getJavaEventMask();

        long accessibilityEventMask = eventHandler->getAccessibilityEventMask();

        if (javaEventMask != 0) {

            addJavaEventNotification(javaEventMask);

        }

        if (accessibilityEventMask != 0) {

            addAccessibilityEventNotification(accessibilityEventMask);

        }

    } else {

        return FALSE;

    }

    return returnVal;

}

// -----------------------

/**

 * sendPackage - uses SendMessage(WM_COPYDATA) to do IPC messaging

 *               with the Java AccessBridge DLL

 *

 *               NOTE: WM_COPYDATA is only for one-way IPC; there

 *               is now way to return parameters (especially big ones)

 *               Use sendMemoryPackage() to do that!

 */

void

WinAccessBridge::sendPackage(char *buffer, long bufsize, HWND destWindow) {

    COPYDATASTRUCT toCopy;

    toCopy.dwData = 0;          // 32-bits we could use for something...

    toCopy.cbData = bufsize;

    toCopy.lpData = buffer;

    SendMessage(destWindow, WM_COPYDATA, (WPARAM) dialogWindow, (LPARAM) &toCopy);

}

/**

 * sendMemoryPackage - uses Memory-Mapped files to do IPC messaging

 *                     with the Java AccessBridge DLL, informing the

 *                     Java AccessBridge DLL via SendMessage that something

 *                     is waiting for it in the shared file...

 *

 *                     In the SendMessage call, the third param (WPARAM) is

 *                     the source HWND (theDialogWindow in this case), and

 *                     the fourth param (LPARAM) is the size in bytes of

 *                     the package put into shared memory.

 *

 */

BOOL

WinAccessBridge::sendMemoryPackage(char *buffer, long bufsize, HWND destWindow) {

    if ((AccessBridgeJavaVMInstance *) 0 == javaVMs) {

        return FALSE;

    }

    AccessBridgeJavaVMInstance *ourABJavaVMInstance;

    ourABJavaVMInstance = javaVMs->findABJavaVMInstanceFromJavaHWND(destWindow);

    if (ourABJavaVMInstance != (AccessBridgeJavaVMInstance *) 0) {

        if (!ourABJavaVMInstance->sendMemoryPackage(buffer, bufsize)) {

            // return falue to the caller

            memset(buffer, 0, bufsize);

            return FALSE;

        }

    } else {

        return FALSE;

    }

    return TRUE;

}

/**

 * queuePackage - put a package onto the queue for latter processing

 *

 */

BOOL

WinAccessBridge::queuePackage(char *buffer, long bufsize) {

    AccessBridgeQueueElement *element = new AccessBridgeQueueElement(buffer, bufsize);

    messageQueue->add(element);

    PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0);

    return TRUE;

}

/**

 * receiveAQueuedPackage - remove a pending packge from the queue and

 *                         handle it. If the queue is busy, post a

 *                         message to self to retrieve it later

 *

 */

BOOL

WinAccessBridge::receiveAQueuedPackage() {

    AccessBridgeQueueElement *element = NULL;

    // ensure against re-entrancy problems...

    if (messageQueue->getRemoveLockSetting() == FALSE) {

        messageQueue->setRemoveLock(TRUE);

        QueueReturns result = messageQueue->remove(&element);

        switch (result) {

        case cQueueBroken:

            messageQueue->setRemoveLock(FALSE);

            return FALSE;

        case cMoreMessages:

        case cQueueEmpty:

            if (element != (AccessBridgeQueueElement *) 0) {

                processPackage(element->buffer, element->bufsize);

                delete element;

            } else {

                return FALSE;

            }

            break;

        case cQueueInUse:

            PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0);

            break;

        default:

            messageQueue->setRemoveLock(FALSE);

            return FALSE;       // should never get something we don't recognize!

        }

    } else {

        PostMessage(dialogWindow, AB_MESSAGE_QUEUED, (WPARAM) 0, (LPARAM) 0); // Fix for 6995891

    }

    messageQueue->setRemoveLock(FALSE);

    return TRUE;

}

// -----------------------

/**

 * preProcessPackage

 *              - do triage on incoming packages; queue some, deal with others

 *

 */

void

WinAccessBridge::preProcessPackage(char *buffer, long bufsize) {

    PackageType *type = (PackageType *) buffer;

    switch (*type) {

    // event packages all get queued for later handling