/*

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

 */

/*

 * Copyright 2003 Wily Technology, Inc.

 */

#include    <jni.h>

#include    <jvm.h>

#include    <jvmti.h>

#include    <stdlib.h>

#include    <string.h>

#include    "JPLISAgent.h"

#include    "JPLISAssert.h"

#include    "Utilities.h"

#include    "Reentrancy.h"

#include    "JavaExceptions.h"

#include    "EncodingSupport.h"

#include    "FileSystemSupport.h"    /* For MAXPATHLEN & uintptr_t */

#include    "sun_instrument_InstrumentationImpl.h"

/*

 *  The JPLISAgent manages the initialization all of the Java programming language Agents.

 *  It also supports the native method bridge between the JPLIS and the JVMTI.

 *  It maintains a single JVMTI Env that all JPL agents share.

 *  It parses command line requests and creates individual Java agents.

 */

/*

 *  private prototypes

 */

/* Allocates an unformatted JPLIS agent data structure. Returns NULL if allocation fails. */

JPLISAgent *

allocateJPLISAgent(jvmtiEnv *       jvmtiEnv);

/* Initializes an already-allocated JPLIS agent data structure. */

JPLISInitializationError

initializeJPLISAgent(   JPLISAgent *    agent,

                        JavaVM *        vm,

                        jvmtiEnv *      jvmtienv);

/* De-allocates a JPLIS agent data structure. Only used in partial-failure cases at startup;

 * in normal usage the JPLIS agent lives forever

 */

void

deallocateJPLISAgent(   jvmtiEnv *      jvmtienv,

                        JPLISAgent *    agent);

/* Does one-time work to interrogate the JVM about capabilities and cache the answers. */

void

checkCapabilities(JPLISAgent * agent);

/* Takes the elements of the command string (agent class name and options string) and

 * create java strings for them.

 * Returns true if a classname was found. Makes no promises beyond the textual; says nothing about whether

 * the class exists or can be loaded.

 * If return value is true, sets outputClassname to a non-NULL local JNI reference.

 * If return value is true, sets outputOptionsString either to NULL or to a non-NULL local JNI reference.

 * If return value is false, neither output parameter is set.

 */

jboolean

commandStringIntoJavaStrings(  JNIEnv *        jnienv,

                               const char *    classname,

                               const char *    optionsString,

                               jstring *       outputClassname,

                               jstring *       outputOptionsString);

/* Start one Java agent from the supplied parameters.

 * Most of the logic lives in a helper function that lives over in Java code--

 * we pass parameters out to Java and use our own Java helper to actually

 * load the agent and call the premain.

 * Returns true if the Java agent class is loaded and the premain/agentmain method completes

 * with no exceptions, false otherwise.

 */

jboolean

invokeJavaAgentMainMethod( JNIEnv *    jnienv,

                           jobject     instrumentationImpl,

                           jmethodID   agentMainMethod,

                           jstring     className,

                           jstring     optionsString);

/* Once we have loaded the Java agent and called the premain,

 * we can release the copies we have been keeping of the command line

 * data (agent class name and option strings).

 */

void

deallocateCommandLineData(JPLISAgent * agent);

/*

 *  Common support for various class list fetchers.

 */

typedef jvmtiError (*ClassListFetcher)

    (   jvmtiEnv *  jvmtiEnv,

        jobject     classLoader,

        jint *      classCount,

        jclass **   classes);

/* Fetcher that ignores the class loader parameter, and uses the JVMTI to get a list of all classes.

 * Returns a jvmtiError according to the underlying JVMTI service.

 */

jvmtiError

getAllLoadedClassesClassListFetcher(    jvmtiEnv *  jvmtiEnv,

                                        jobject     classLoader,

                                        jint *      classCount,

                                        jclass **   classes);

/* Fetcher that uses the class loader parameter, and uses the JVMTI to get a list of all classes

 * for which the supplied loader is the initiating loader.

 * Returns a jvmtiError according to the underlying JVMTI service.

 */

jvmtiError

getInitiatedClassesClassListFetcher(    jvmtiEnv *  jvmtiEnv,

                                        jobject     classLoader,

                                        jint *      classCount,

                                        jclass **   classes);

/*

 * Common guts for two native methods, which are the same except for the policy for fetching

 * the list of classes.

 * Either returns a local JNI reference to an array of references to java.lang.Class.

 * Can throw, if it does will alter the JNIEnv with an outstanding exception.

 */

jobjectArray

commonGetClassList( JNIEnv *            jnienv,

                    JPLISAgent *        agent,

                    jobject             classLoader,

                    ClassListFetcher    fetcher);

/*

 *  Misc. utilities.

 */

/* Checked exception mapper used by the redefine classes implementation.

 * Allows ClassNotFoundException or UnmodifiableClassException; maps others

 * to InternalError. Can return NULL in an error case.

 */

jthrowable

redefineClassMapper(    JNIEnv *    jnienv,

                        jthrowable  throwableToMap);

/* Turns a buffer of jclass * into a Java array whose elements are java.lang.Class.

 * Can throw, if it does will alter the JNIEnv with an outstanding exception.

 */

jobjectArray

getObjectArrayFromClasses(JNIEnv* jnienv, jclass* classes, jint classCount);

JPLISEnvironment *

getJPLISEnvironment(jvmtiEnv * jvmtienv) {

    JPLISEnvironment * environment  = NULL;

    jvmtiError         jvmtierror   = JVMTI_ERROR_NONE;

    jvmtierror = (*jvmtienv)->GetEnvironmentLocalStorage(

                                            jvmtienv,

                                            (void**)&environment);

    /* can be called from any phase */

    jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

    if (jvmtierror == JVMTI_ERROR_NONE) {

        jplis_assert(environment != NULL);

        jplis_assert(environment->mJVMTIEnv == jvmtienv);

    } else {

        environment = NULL;

    }

    return environment;

}

/*

 *  OnLoad processing code.

 */

/*

 *  Creates a new JPLISAgent.

 *  Returns error if the agent cannot be created and initialized.

 *  The JPLISAgent* pointed to by agent_ptr is set to the new broker,

 *  or NULL if an error has occurred.

 */

JPLISInitializationError

createNewJPLISAgent(JavaVM * vm, JPLISAgent **agent_ptr) {

    JPLISInitializationError initerror       = JPLIS_INIT_ERROR_NONE;

    jvmtiEnv *               jvmtienv        = NULL;

    jint                     jnierror        = JNI_OK;

    *agent_ptr = NULL;

    jnierror = (*vm)->GetEnv(  vm,

                               (void **) &jvmtienv,

                               JVMTI_VERSION_1_1);

    if ( jnierror != JNI_OK ) {

        initerror = JPLIS_INIT_ERROR_CANNOT_CREATE_NATIVE_AGENT;

    } else {

        JPLISAgent * agent = allocateJPLISAgent(jvmtienv);

        if ( agent == NULL ) {

            initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;

        } else {

            initerror = initializeJPLISAgent(  agent,

                                               vm,

                                               jvmtienv);

            if ( initerror == JPLIS_INIT_ERROR_NONE ) {

                *agent_ptr = agent;

            } else {

                deallocateJPLISAgent(jvmtienv, agent);

            }

        }

        /* don't leak envs */

        if ( initerror != JPLIS_INIT_ERROR_NONE ) {

            jvmtiError jvmtierror = (*jvmtienv)->DisposeEnvironment(jvmtienv);

            /* can be called from any phase */

            jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

        }

    }

    return initerror;

}

/*

 *  Allocates a JPLISAgent. Returns NULL if it cannot be allocated

 */

JPLISAgent *

allocateJPLISAgent(jvmtiEnv * jvmtienv) {

  return (JPLISAgent *) allocate( jvmtienv,

                                    sizeof(JPLISAgent));

}

JPLISInitializationError

initializeJPLISAgent(   JPLISAgent *    agent,

                        JavaVM *        vm,

                        jvmtiEnv *      jvmtienv) {

    jvmtiError      jvmtierror = JVMTI_ERROR_NONE;

    jvmtiPhase      phase;

    agent->mJVM                                      = vm;

    agent->mNormalEnvironment.mJVMTIEnv              = jvmtienv;

    agent->mNormalEnvironment.mAgent                 = agent;

    agent->mNormalEnvironment.mIsRetransformer       = JNI_FALSE;

    agent->mRetransformEnvironment.mJVMTIEnv         = NULL;        /* NULL until needed */

    agent->mRetransformEnvironment.mAgent            = agent;

    agent->mRetransformEnvironment.mIsRetransformer  = JNI_FALSE;   /* JNI_FALSE until mJVMTIEnv is set */

    agent->mAgentmainCaller                          = NULL;

    agent->mInstrumentationImpl                      = NULL;

    agent->mPremainCaller                            = NULL;

    agent->mTransform                                = NULL;

    agent->mRedefineAvailable                        = JNI_FALSE;   /* assume no for now */

    agent->mRedefineAdded                            = JNI_FALSE;

    agent->mNativeMethodPrefixAvailable              = JNI_FALSE;   /* assume no for now */

    agent->mNativeMethodPrefixAdded                  = JNI_FALSE;

    agent->mAgentClassName                           = NULL;

    agent->mOptionsString                            = NULL;

    agent->mJarfile                                  = NULL;

    /* make sure we can recover either handle in either direction.

     * the agent has a ref to the jvmti; make it mutual

     */

    jvmtierror = (*jvmtienv)->SetEnvironmentLocalStorage(

                                            jvmtienv,

                                            &(agent->mNormalEnvironment));

    /* can be called from any phase */

    jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

    /* check what capabilities are available */

    checkCapabilities(agent);

    /* check phase - if live phase then we don't need the VMInit event */

    jvmtierror = (*jvmtienv)->GetPhase(jvmtienv, &phase);

    /* can be called from any phase */

    jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

    if (phase == JVMTI_PHASE_LIVE) {

        return JPLIS_INIT_ERROR_NONE;

    }

    if (phase != JVMTI_PHASE_ONLOAD) {

        /* called too early or called too late; either way bail out */

        return JPLIS_INIT_ERROR_FAILURE;

    }

    /* now turn on the VMInit event */

    if ( jvmtierror == JVMTI_ERROR_NONE ) {

        jvmtiEventCallbacks callbacks;

        memset(&callbacks, 0, sizeof(callbacks));

        callbacks.VMInit = &eventHandlerVMInit;

        jvmtierror = (*jvmtienv)->SetEventCallbacks( jvmtienv,

                                                     &callbacks,

                                                     sizeof(callbacks));

        check_phase_ret_blob(jvmtierror, JPLIS_INIT_ERROR_FAILURE);

        jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

    }

    if ( jvmtierror == JVMTI_ERROR_NONE ) {

        jvmtierror = (*jvmtienv)->SetEventNotificationMode(

                                                jvmtienv,

                                                JVMTI_ENABLE,

                                                JVMTI_EVENT_VM_INIT,

                                                NULL /* all threads */);

        check_phase_ret_blob(jvmtierror, JPLIS_INIT_ERROR_FAILURE);

        jplis_assert(jvmtierror == JVMTI_ERROR_NONE);

    }

    return (jvmtierror == JVMTI_ERROR_NONE)? JPLIS_INIT_ERROR_NONE : JPLIS_INIT_ERROR_FAILURE;

}

void

deallocateJPLISAgent(jvmtiEnv * jvmtienv, JPLISAgent * agent) {

    deallocate(jvmtienv, agent);

}

JPLISInitializationError

recordCommandLineData(  JPLISAgent *    agent,

                        const char *    agentClassName,

                        const char *    optionsString ) {

    JPLISInitializationError    initerror   = JPLIS_INIT_ERROR_NONE;

    char *      ourCopyOfAgentClassName     = NULL;

    char *      ourCopyOfOptionsString      = NULL;

    /* if no actual params, bail out now */

    if ((agentClassName == NULL) || (*agentClassName == 0)) {

        initerror = JPLIS_INIT_ERROR_AGENT_CLASS_NOT_SPECIFIED;

    } else {

        ourCopyOfAgentClassName = allocate(jvmti(agent), strlen(agentClassName)+1);

        if (ourCopyOfAgentClassName == NULL) {

            initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;

        } else {

            if (optionsString != NULL) {

                ourCopyOfOptionsString = allocate(jvmti(agent), strlen(optionsString)+1);

                if (ourCopyOfOptionsString == NULL) {

                    deallocate(jvmti(agent), ourCopyOfAgentClassName);

                    initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;

                }

            }

        }

    }

    if (initerror == JPLIS_INIT_ERROR_NONE) {

        strcpy(ourCopyOfAgentClassName, agentClassName);

        if (optionsString != NULL) {

            strcpy(ourCopyOfOptionsString, optionsString);

        }

        agent->mAgentClassName = ourCopyOfAgentClassName;

        agent->mOptionsString = ourCopyOfOptionsString;

    }

    return initerror;

}

/*

 *  VMInit processing code.

 */

/*

 * If this call fails, the JVM launch will ultimately be aborted,

 * so we don't have to be super-careful to clean up in partial failure

 * cases.

 */

jboolean

processJavaStart(   JPLISAgent *    agent,

                    JNIEnv *        jnienv) {

    jboolean    result;

    /*

     *  OK, Java is up now. We can start everything that needs Java.

     */

    /*

     *  First make our emergency fallback InternalError throwable.

     */

    result = initializeFallbackError(jnienv);

    jplis_assert(result);

    /*

     *  Now make the InstrumentationImpl instance.

     */

    if ( result ) {

        result = createInstrumentationImpl(jnienv, agent);

        jplis_assert(result);

    }

    /*

     *  Then turn off the VMInit handler and turn on the ClassFileLoadHook.

     *  This way it is on before anyone registers a transformer.

     */

    if ( result ) {

        result = setLivePhaseEventHandlers(agent);

        jplis_assert(result);

    }

    /*

     *  Load the Java agent, and call the premain.

     */

    if ( result ) {

        result = startJavaAgent(agent, jnienv,

                                agent->mAgentClassName, agent->mOptionsString,

                                agent->mPremainCaller);

    }

    /*

     * Finally surrender all of the tracking data that we don't need any more.

     * If something is wrong, skip it, we will be aborting the JVM anyway.

     */

    if ( result ) {

        deallocateCommandLineData(agent);

    }

    return result;

}

jboolean

startJavaAgent( JPLISAgent *    agent,

                JNIEnv *        jnienv,

                const char *    classname,

                const char *    optionsString,

                jmethodID       agentMainMethod) {

    jboolean    success = JNI_FALSE;

    jstring classNameObject = NULL;

    jstring optionsStringObject = NULL;

    success = commandStringIntoJavaStrings(    jnienv,

                                               classname,

                                               optionsString,

                                               &classNameObject,

                                               &optionsStringObject);

    if (success) {

        success = invokeJavaAgentMainMethod(   jnienv,

                                               agent->mInstrumentationImpl,

                                               agentMainMethod,

                                               classNameObject,

                                               optionsStringObject);

    }

    return success;

}

void

deallocateCommandLineData( JPLISAgent * agent) {

    deallocate(jvmti(agent), (void*)agent->mAgentClassName);

    deallocate(jvmti(agent), (void*)agent->mOptionsString);

    /* zero things out so it is easier to see what is going on */

    agent->mAgentClassName = NULL;

    agent->mOptionsString = NULL;

}

/*

 * Create the java.lang.instrument.Instrumentation instance

 * and access information for it (method IDs, etc)

 */

jboolean

createInstrumentationImpl( JNIEnv *        jnienv,

                           JPLISAgent *    agent) {

    jclass      implClass               = NULL;

    jboolean    errorOutstanding        = JNI_FALSE;

    jobject     resultImpl              = NULL;

    jmethodID   premainCallerMethodID   = NULL;

    jmethodID   agentmainCallerMethodID = NULL;

    jmethodID   transformMethodID       = NULL;

    jmethodID   constructorID           = NULL;

    jobject     localReference          = NULL;

    /* First find the class of our implementation */

    implClass = (*jnienv)->FindClass(   jnienv,

                                        JPLIS_INSTRUMENTIMPL_CLASSNAME);

    errorOutstanding = checkForAndClearThrowable(jnienv);

    errorOutstanding = errorOutstanding || (implClass == NULL);

    jplis_assert_msg(!errorOutstanding, "find class on InstrumentationImpl failed");

    if ( !errorOutstanding ) {

        constructorID = (*jnienv)->GetMethodID( jnienv,

                                                implClass,

                                                JPLIS_INSTRUMENTIMPL_CONSTRUCTOR_METHODNAME,

                                                JPLIS_INSTRUMENTIMPL_CONSTRUCTOR_METHODSIGNATURE);

        errorOutstanding = checkForAndClearThrowable(jnienv);

        errorOutstanding = errorOutstanding || (constructorID == NULL);

        jplis_assert_msg(!errorOutstanding, "find constructor on InstrumentationImpl failed");

        }

    if ( !errorOutstanding ) {

        jlong   peerReferenceAsScalar = (jlong)(intptr_t) agent;

        localReference = (*jnienv)->NewObject(  jnienv,

                                                implClass,

                                                constructorID,

                                                peerReferenceAsScalar,

                                                agent->mRedefineAdded,

                                                agent->mNativeMethodPrefixAdded);

        errorOutstanding = checkForAndClearThrowable(jnienv);

        errorOutstanding = errorOutstanding || (localReference == NULL);

        jplis_assert_msg(!errorOutstanding, "call constructor on InstrumentationImpl failed");

    }

    if ( !errorOutstanding ) {

        resultImpl = (*jnienv)->NewGlobalRef(jnienv, localReference);

        errorOutstanding = checkForAndClearThrowable(jnienv);

        jplis_assert_msg(!errorOutstanding, "copy local ref to global ref");

    }

    /* Now look up the method ID for the pre-main caller (we will need this more than once) */

    if ( !errorOutstanding ) {