/*

 * Copyright (c) 2005, 2015, 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 Java applications to handle communication

 * between Java VMs purposes of Accessbility.

 */

#include "AccessBridgeDebug.h"

#include "JavaAccessBridge.h"

#include "com_sun_java_accessibility_AccessBridge.h" // programatically generated by JNI

#include "accessBridgeResource.h"

#include "accessBridgeCallbacks.h"

#include "AccessBridgeMessages.h"

#include <windows.h>

#include <stdio.h>

#include <jawt.h>

#include <jawt_md.h>

JavaAccessBridge *theJavaAccessBridge;

HWND theDialogWindow;

// re-entrance lock for receiving memory messages

CRITICAL_SECTION receiveMemoryIPCLock;

// unique broadcast msg. IDs gotten dymanically

extern UINT theFromJavaHelloMsgID;

extern UINT theFromWindowsHelloMsgID;

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

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:

            InitializeCriticalSection(&receiveMemoryIPCLock);

            theJavaAccessBridge = new JavaAccessBridge(hinstDll);

            break;

        case DLL_PROCESS_DETACH:        // A Windows executable unloaded us

            if (theJavaAccessBridge != (JavaAccessBridge *) 0) {

                delete theJavaAccessBridge;

                DeleteCriticalSection(&receiveMemoryIPCLock);

            }

            break;

        }

        return TRUE;

    }

    /**

     * Open a native window (and init the wrappers we'll be using)

     *

     */

    JNIEXPORT void JNICALL

    Java_com_sun_java_accessibility_AccessBridge_runDLL(JNIEnv *env, jobject obj) {

        PrintDebugString("\r\nJavaAccessBridge.DLL runDLL() called");

        theJavaAccessBridge->javaRun(env, obj);

    }

#if 0 // SetDlgItemText has caused problems with JAWS

    /**

     * Append debug info to dialog

     *

     */

    void AppendToCallInfo(char *s) {

        char buffer[4096];

        PrintDebugString(s);

        GetDlgItemText(theDialogWindow, cCallInfo, buffer, sizeof(buffer));

        if (strlen(buffer) < (sizeof(buffer) - strlen(s))) {

            strncat(buffer, s, sizeof(buffer));

            SetDlgItemText(theDialogWindow, cCallInfo, buffer);

        } else {

            SetDlgItemText(theDialogWindow, cCallInfo, s);

        }

    }

#endif

    /**

     * Our window proc

     *

     */

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

        int command;

        COPYDATASTRUCT *sentToUs;

        char *package;

        //DEBUG_CODE(char buffer[256]);

        switch (message) {

        case WM_INITDIALOG:

            //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, "Initializing"));

            break;

        case WM_COMMAND:

            command = LOWORD (wParam);

            break;

            // call from Java with data for us to deliver

        case WM_COPYDATA:

            if (theDialogWindow == (HWND) wParam) {

                //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, "Got WM_COPYDATA from ourselves"));

            } else {

                //DEBUG_CODE(sprintf(buffer, "Got WM_COPYDATA from HWND %p", wParam));

                //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, buffer));

                sentToUs = (COPYDATASTRUCT *) lParam;

                package = (char *) sentToUs->lpData;

                theJavaAccessBridge->processPackage(package, sentToUs->cbData);

            }

            break;

            // call from Java with data for us retrieve from memory mapped file and deliver

        case AB_MESSAGE_WAITING:

            // wParam == sourceHwnd

            // lParam == buffer size in shared memory

            if (theDialogWindow == (HWND) wParam) {

                //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, "Got AB_MESSAGE_WAITING from ourselves"));

            } else {

                //DEBUG_CODE(sprintf(buffer, "Got AB_MESSAGE_WAITING from HWND %p", wParam));

                //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, buffer));

                LRESULT returnVal = theJavaAccessBridge->receiveMemoryPackage((HWND) wParam, lParam);

            }

            break;

            // a JavaAccessBridge DLL is going away

        case AB_DLL_GOING_AWAY:

            // wParam == sourceHwnd

            //DEBUG_CODE(SetDlgItemText(theDialogWindow, cStatusText, "Got AB_DLL_GOING_AWAY message"));

            theJavaAccessBridge->WindowsATDestroyed((HWND) wParam);

            break;

        default:

            // the Windows AT is saying "hi"!

            // wParam == sourceHwnc; lParam unused

            if (message == theFromWindowsHelloMsgID) {

                // A new Windows AT just said "hi";

                // say "hi" back so it can mate up with us

                // otherwise don't do anything (e.g. don't set up data structures yet)

                theJavaAccessBridge->postHelloToWindowsDLLMsg((HWND) wParam);

            }

        }

        return FALSE;

    }

}

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

/**

 * Initialize the JavaAccessBridge

 *

 */

JavaAccessBridge::JavaAccessBridge(HINSTANCE hInstance) {

    windowsInstance = hInstance;

    ATs = (AccessBridgeATInstance *) 0;

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

}

extern DWORD JavaBridgeThreadId;

/**

 * Destroy the JavaAccessBridge

 *

 */

JavaAccessBridge::~JavaAccessBridge() {

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

    PrintDebugString("\r\nin JavaAccessBridge::~JavaAccessBridge()");

    // Send a shutdown message for those applications like StarOffice that do

    // send a shutdown message themselves.

    javaShutdown(NULL, 0);

    AccessBridgeATInstance *current = ATs;

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

        PrintDebugString("  telling %p we're going away", current->winAccessBridgeWindow);

                SendMessage(current->winAccessBridgeWindow,

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

        current = current->nextATInstance;

    }

    PrintDebugString("  finished telling ATs about our demise");

        if(JavaBridgeThreadId)

                {

                PostThreadMessage(JavaBridgeThreadId,WM_USER+1,0,0);

                Sleep(100);

                }

    delete ATs;

    PrintDebugString("  finished deleting ATs");

    PrintDebugString("GOODBYE CRUEL WORLD...");

}

void

JavaAccessBridge::javaRun(JNIEnv *env, jobject obj) {

    MSG msg;

    PrintDebugString("JavaAccessBridge::javaRun(%p, %p) called", env, obj);

    if (env->GetJavaVM(&javaVM) != 0) {

        return; // huh!?!?!

    }

    PrintDebugString("  -> javaVM = %p", javaVM);

    if (javaVM->AttachCurrentThread((void **) &windowsThreadJNIEnv, NULL) != 0) {

        return; // huh!?!?!

    }

    PrintDebugString("  -> windowsThreadJNIEnv = %p", windowsThreadJNIEnv);

    javaThreadABObject = env->NewGlobalRef(obj);

    windowsThreadABObject = windowsThreadJNIEnv->NewGlobalRef(obj);

    // initialize the Java thread AccessBridge entry points

    javaThreadEntryPoints = new AccessBridgeJavaEntryPoints(env, javaThreadABObject);

    if (javaThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {

        return;         // couldn't build our entry points; let's get out of here!

    }

    PrintDebugString("  all Java thread entry points successfully found.");

    // initialize the Windows thread AccessBridge entry points

    windowsThreadEntryPoints = new AccessBridgeJavaEntryPoints(windowsThreadJNIEnv,

                                                               windowsThreadABObject);

    if (windowsThreadEntryPoints->BuildJavaEntryPoints() == FALSE) {

        return;         // couldn't build our entry points; let's get out of here!

    }

    PrintDebugString("  all Windows thread entry points successfully found.");

    // open our window

    if (initWindow() == TRUE) {

        PrintDebugString("  Window created.  HWND = %p", dialogWindow);

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

        postHelloToWindowsDLLMsg(HWND_BROADCAST);

        // do that message loop thing

        while (GetMessage(&msg, NULL, 0, 0)) {

            TranslateMessage(&msg);

            DispatchMessage(&msg);

        }

    } else {

        PrintDebugString("  FAILED TO CREATE WINDOW!!!");

    }

    javaVM->DetachCurrentThread();

}

/**

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

 *

 */

BOOL

JavaAccessBridge::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));

    return TRUE;

}

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

/**

 * postHelloToWindowsDLLMsg

 *          - PostMessage(theFromJavaHelloMsgID) to let one or

 *            all WindowDLLs we're here and have a vmID

 *

 *            destHwnd is either a single hwnd or HWND_BROADCAST

 *              (former if a reply, latter if we're just born)

 *            wParam is our HWND

 *            lParam is our vmID

 *

 */

void

JavaAccessBridge::postHelloToWindowsDLLMsg(HWND destHwnd) {

    PrintDebugString("\r\nin JavaAccessBridge::postHelloToWindowsDLLMsg");

    PrintDebugString("  calling PostMessage(%p, %X, %p, %p)",

                     destHwnd, theFromJavaHelloMsgID, dialogWindow, javaVM);

    PostMessage(destHwnd, theFromJavaHelloMsgID, (WPARAM) dialogWindow, (LPARAM) dialogWindow);

}

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

/**

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

 *                                with the Java AccessBridge DLL

 *

 */

void

JavaAccessBridge::sendPackage(char *buffer, int bufsize, HWND destHwnd) {

    COPYDATASTRUCT toCopy;

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

    toCopy.cbData = bufsize;

    toCopy.lpData = buffer;

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

}

/**

 * sendJavaEventPackage - walk through ATs, sending event messages to 'em

 *

 */

void

JavaAccessBridge::sendJavaEventPackage(char *buffer, int bufsize, long type) {

    PrintDebugString("JavaAccessBridge::sendJavaEventPackage(), type = %X", type);

    if (ATs == (AccessBridgeATInstance *) 0) {

        PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");

    }

    AccessBridgeATInstance *ati = ATs;

    while (ati != (AccessBridgeATInstance *) 0) {

        ati->sendJavaEventPackage(buffer, bufsize, type);

        ati = ati->nextATInstance;

    }

}

/**

 * sendAccessibilityEventPackage - walk through ATs, sending event messages to 'em

 *

 */

void

JavaAccessBridge::sendAccessibilityEventPackage(char *buffer, int bufsize, long type) {

    PrintDebugString("JavaAccessBridge::sendAccessibilityEventPackage(), type = %X", type);

    if (ATs == (AccessBridgeATInstance *) 0) {

        PrintDebugString("  ERROR!! ATs == 0! (shouldn't happen here!)");

    }

    AccessBridgeATInstance *ati = ATs;

    while (ati != (AccessBridgeATInstance *) 0) {

        ati->sendAccessibilityEventPackage(buffer, bufsize, type);

        ati = ati->nextATInstance;

    }

}

/**

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

 *                        with the Java AccessBridge DLL, receiving the

 *                        message from Java AccessBridge DLL by reading the

 *                        contents of the shared memory mapped file that

 *                        is used for Java-initiated messages

 *

 */

BOOL

JavaAccessBridge::receiveMemoryPackage(HWND srcWindow, long bufsize) {

    char *IPCview;

    PrintDebugString("\r\nJavaAccessBridge::receiveMemoryPackage(%p, %d)", srcWindow, bufsize);

    // look-up the appropriate IPCview based on the srcHWND of the Windows AccessBridge DLL

    if (ATs == (AccessBridgeATInstance *) 0) {

        PrintDebugString("  ERROR! - ATs == 0 (shouldn't happen in receiveMemoryPackage()!");

        return FALSE;

    }

    AccessBridgeATInstance *ati = ATs->findABATInstanceFromATHWND(srcWindow);

    if (ati != (AccessBridgeATInstance *) 0) {

        IPCview = (char *) ati->memoryMappedView;

        // wait for the lock if someone else has it (re-entrancy)

        EnterCriticalSection(&receiveMemoryIPCLock);

        {

            // set byte at end of buffer to indicate to caller that we have reached this point

            IPCview[bufsize] = 1;

            // process the package

            processPackage(IPCview, bufsize);

        }

        // release re-entrance lock

        LeaveCriticalSection(&receiveMemoryIPCLock);

        return TRUE;

    } else {

        //DEBUG_CODE(AppendToCallInfo("ERROR receiving memory package: couldn't find srcWindow"));

        PrintDebugString("ERROR receiving memory package: couldn't find srcWindow");

        return FALSE;

    }

}

/**

 * processPackage - processes the output of SendMessage(WM_COPYDATA)

 *                                      to do IPC messaging with the Windows AccessBridge DLL

 *

 */

LRESULT

JavaAccessBridge::processPackage(char *buffer, int bufsize) {

    PrintDebugString("\r\nProcessing package sent from Windows, bufsize = %d:", bufsize);

    PackageType *type = (PackageType *) buffer;

    LRESULT returnVal = 0;

    PrintDebugString("  PackageType = %X:", *type);

    jobject rAC;

    switch (*type) {

    case cMemoryMappedFileCreatedPackage:

        // Windows is telling us it created a memory mapped file for us to use

        // in repsonding to various information querying packages (see below)

        PrintDebugString("   type == cMemoryMappedFileCreatedPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage))) {

            MemoryMappedFileCreatedPackage *pkg =

                (MemoryMappedFileCreatedPackage *) (buffer + sizeof(PackageType));

            returnVal = MemoryMappedFileCreated((HWND)ABLongToHandle(pkg->bridgeWindow), pkg->filename);

        } else {

            PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",

                             bufsize, sizeof(PackageType) + sizeof(MemoryMappedFileCreatedPackage));

        }

        break;

        // ------------ information querying packages ------------------

    case cReleaseJavaObjectPackage:

        PrintDebugString("   type == cReleaseJavaObjectPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage))) {

            ReleaseJavaObjectPackage *pkg =

                (ReleaseJavaObjectPackage *) (buffer + sizeof(PackageType));

            releaseJavaObject((jobject)pkg->object);

        } else {

            PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",

                             bufsize, sizeof(PackageType) + sizeof(ReleaseJavaObjectPackage));

        }

        break;

    case cGetAccessBridgeVersionPackage:

        PrintDebugString("   type == cGetAccessBridgeVersionPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage))) {

            GetAccessBridgeVersionPackage *pkg =

                (GetAccessBridgeVersionPackage *) (buffer + sizeof(PackageType));

            windowsThreadEntryPoints->getVersionInfo(&(pkg->rVersionInfo));

        } else {

            PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",

                             bufsize, sizeof(PackageType) + sizeof(GetAccessBridgeVersionPackage));

        }

        break;

    case cIsJavaWindowPackage:

        PrintDebugString("   type == cIsJavaWindowPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(IsJavaWindowPackage))) {

            IsJavaWindowPackage *pkg =

                (IsJavaWindowPackage *) (buffer + sizeof(PackageType));

            pkg->rResult =

                windowsThreadEntryPoints->isJavaWindow(pkg->window);

            PrintDebugString("     -> returning result = %d", pkg->rResult);

        } else {

            PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",

                             bufsize, sizeof(PackageType) + sizeof(IsJavaWindowPackage));

        }

        break;

    case cIsSameObjectPackage:

        PrintDebugString("   type == cIsSameObjectPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(IsSameObjectPackage))) {

            IsSameObjectPackage *pkg =

                (IsSameObjectPackage *) (buffer + sizeof(PackageType));

            pkg->rResult =

                windowsThreadEntryPoints->isSameObject((jobject)pkg->obj1, (jobject)pkg->obj2);

            PrintDebugString("     -> returning result = %d", pkg->rResult);

        } else {

            PrintDebugString("   processing FAILED!! -> bufsize = %d; expectation = %d",

                             bufsize, sizeof(PackageType) + sizeof(IsSameObjectPackage));

        }

        break;

    case cGetAccessibleContextFromHWNDPackage:

        PrintDebugString("   type == cGetAccessibleContextFromHWNDPackage");

        if (bufsize == (sizeof(PackageType) + sizeof(GetAccessibleContextFromHWNDPackage))) {

            GetAccessibleContextFromHWNDPackage *pkg =

                (GetAccessibleContextFromHWNDPackage *) (buffer + sizeof(PackageType));