--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.instrument/share/native/libinstrument/InvocationAdapter.c Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,945 @@
+/*
+ * Copyright (c) 2003, 2017, 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 <string.h>
+#include <stdlib.h>
+
+#include "jni.h"
+
+#include "Utilities.h"
+#include "JPLISAssert.h"
+#include "JPLISAgent.h"
+#include "JavaExceptions.h"
+
+#include "EncodingSupport.h"
+#include "FileSystemSupport.h"
+#include "JarFacade.h"
+#include "PathCharsValidator.h"
+
+/**
+ * This module contains the direct interface points with the JVMTI.
+ * The OnLoad handler is here, along with the various event handlers.
+ */
+
+static int
+appendClassPath(JPLISAgent* agent,
+ const char* jarfile);
+
+static void
+appendBootClassPath(JPLISAgent* agent,
+ const char* jarfile,
+ const char* pathList);
+
+
+/*
+ * Parse -javaagent tail, of the form name[=options], into name
+ * and options. Returned values are heap allocated and options maybe
+ * NULL. Returns 0 if parse succeeds, -1 if allocation fails.
+ */
+static int
+parseArgumentTail(char* tail, char** name, char** options) {
+ int len;
+ char* pos;
+
+ pos = strchr(tail, '=');
+ len = (pos == NULL) ? (int)strlen(tail) : (int)(pos - tail);
+
+ *name = (char*)malloc(len+1);
+ if (*name == NULL) {
+ return -1;
+ }
+ memcpy(*name, tail, len);
+ (*name)[len] = '\0';
+
+ if (pos == NULL) {
+ *options = NULL;
+ } else {
+ char * str = (char*)malloc( (int)strlen(pos + 1) + 1 );
+ if (str == NULL) {
+ free(*name);
+ return -1;
+ }
+ strcpy(str, pos +1);
+ *options = str;
+ }
+ return 0;
+}
+
+/*
+ * Get the value of an attribute in an attribute list. Returns NULL
+ * if attribute not found.
+ */
+jboolean
+getBooleanAttribute(const jarAttribute* attributes, const char* name) {
+ char* attributeValue = getAttribute(attributes, name);
+ return attributeValue != NULL && strcasecmp(attributeValue, "true") == 0;
+}
+
+/*
+ * Parse any capability settings in the JAR manifest and
+ * convert them to JVM TI capabilities.
+ */
+void
+convertCapabilityAttributes(const jarAttribute* attributes, JPLISAgent* agent) {
+ /* set redefineClasses capability */
+ if (getBooleanAttribute(attributes, "Can-Redefine-Classes")) {
+ addRedefineClassesCapability(agent);
+ }
+
+ /* create an environment which has the retransformClasses capability */
+ if (getBooleanAttribute(attributes, "Can-Retransform-Classes")) {
+ retransformableEnvironment(agent);
+ }
+
+ /* set setNativeMethodPrefix capability */
+ if (getBooleanAttribute(attributes, "Can-Set-Native-Method-Prefix")) {
+ addNativeMethodPrefixCapability(agent);
+ }
+
+ /* for retransformClasses testing, set capability to use original method order */
+ if (getBooleanAttribute(attributes, "Can-Maintain-Original-Method-Order")) {
+ addOriginalMethodOrderCapability(agent);
+ }
+}
+
+/*
+ * This will be called once for every -javaagent on the command line.
+ * Each call to Agent_OnLoad will create its own agent and agent data.
+ *
+ * The argument tail string provided to Agent_OnLoad will be of form
+ * <jarfile>[=<options>]. The tail string is split into the jarfile and
+ * options components. The jarfile manifest is parsed and the value of the
+ * Premain-Class attribute will become the agent's premain class. The jar
+ * file is then added to the system class path, and if the Boot-Class-Path
+ * attribute is present then all relative URLs in the value are processed
+ * to create boot class path segments to append to the boot class path.
+ */
+JNIEXPORT jint JNICALL
+DEF_Agent_OnLoad(JavaVM *vm, char *tail, void * reserved) {
+ JPLISInitializationError initerror = JPLIS_INIT_ERROR_NONE;
+ jint result = JNI_OK;
+ JPLISAgent * agent = NULL;
+
+ initerror = createNewJPLISAgent(vm, &agent);
+ if ( initerror == JPLIS_INIT_ERROR_NONE ) {
+ int oldLen, newLen;
+ char * jarfile;
+ char * options;
+ jarAttribute* attributes;
+ char * premainClass;
+ char * bootClassPath;
+
+ /*
+ * Parse <jarfile>[=options] into jarfile and options
+ */
+ if (parseArgumentTail(tail, &jarfile, &options) != 0) {
+ fprintf(stderr, "-javaagent: memory allocation failure.\n");
+ return JNI_ERR;
+ }
+
+ /*
+ * Agent_OnLoad is specified to provide the agent options
+ * argument tail in modified UTF8. However for 1.5.0 this is
+ * actually in the platform encoding - see 5049313.
+ *
+ * Open zip/jar file and parse archive. If can't be opened or
+ * not a zip file return error. Also if Premain-Class attribute
+ * isn't present we return an error.
+ */
+ attributes = readAttributes(jarfile);
+ if (attributes == NULL) {
+ fprintf(stderr, "Error opening zip file or JAR manifest missing : %s\n", jarfile);
+ free(jarfile);
+ if (options != NULL) free(options);
+ return JNI_ERR;
+ }
+
+ premainClass = getAttribute(attributes, "Premain-Class");
+ if (premainClass == NULL) {
+ fprintf(stderr, "Failed to find Premain-Class manifest attribute in %s\n",
+ jarfile);
+ free(jarfile);
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ return JNI_ERR;
+ }
+
+ /* Save the jarfile name */
+ agent->mJarfile = jarfile;
+
+ /*
+ * The value of the Premain-Class attribute becomes the agent
+ * class name. The manifest is in UTF8 so need to convert to
+ * modified UTF8 (see JNI spec).
+ */
+ oldLen = (int)strlen(premainClass);
+ newLen = modifiedUtf8LengthOfUtf8(premainClass, oldLen);
+ if (newLen == oldLen) {
+ premainClass = strdup(premainClass);
+ } else {
+ char* str = (char*)malloc( newLen+1 );
+ if (str != NULL) {
+ convertUtf8ToModifiedUtf8(premainClass, oldLen, str, newLen);
+ }
+ premainClass = str;
+ }
+ if (premainClass == NULL) {
+ fprintf(stderr, "-javaagent: memory allocation failed\n");
+ free(jarfile);
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ return JNI_ERR;
+ }
+
+ /*
+ * If the Boot-Class-Path attribute is specified then we process
+ * each relative URL and add it to the bootclasspath.
+ */
+ bootClassPath = getAttribute(attributes, "Boot-Class-Path");
+ if (bootClassPath != NULL) {
+ appendBootClassPath(agent, jarfile, bootClassPath);
+ }
+
+ /*
+ * Convert JAR attributes into agent capabilities
+ */
+ convertCapabilityAttributes(attributes, agent);
+
+ /*
+ * Track (record) the agent class name and options data
+ */
+ initerror = recordCommandLineData(agent, premainClass, options);
+
+ /*
+ * Clean-up
+ */
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ free(premainClass);
+ }
+
+ switch (initerror) {
+ case JPLIS_INIT_ERROR_NONE:
+ result = JNI_OK;
+ break;
+ case JPLIS_INIT_ERROR_CANNOT_CREATE_NATIVE_AGENT:
+ result = JNI_ERR;
+ fprintf(stderr, "java.lang.instrument/-javaagent: cannot create native agent.\n");
+ break;
+ case JPLIS_INIT_ERROR_FAILURE:
+ result = JNI_ERR;
+ fprintf(stderr, "java.lang.instrument/-javaagent: initialization of native agent failed.\n");
+ break;
+ case JPLIS_INIT_ERROR_ALLOCATION_FAILURE:
+ result = JNI_ERR;
+ fprintf(stderr, "java.lang.instrument/-javaagent: allocation failure.\n");
+ break;
+ case JPLIS_INIT_ERROR_AGENT_CLASS_NOT_SPECIFIED:
+ result = JNI_ERR;
+ fprintf(stderr, "-javaagent: agent class not specified.\n");
+ break;
+ default:
+ result = JNI_ERR;
+ fprintf(stderr, "java.lang.instrument/-javaagent: unknown error\n");
+ break;
+ }
+ return result;
+}
+
+/*
+ * Agent_OnAttach returns a jint. 0/JNI_OK indicates success and non-0
+ * indicates an error. To allow the attach mechanism throw an
+ * AgentInitializationException with a reasonable exception message we define
+ * a few specific errors here.
+ */
+#define AGENT_ERROR_BADJAR ((jint)100) /* Agent JAR not found or no Agent-Class attribute */
+#define AGENT_ERROR_NOTONCP ((jint)101) /* Unable to add JAR file to system class path */
+#define AGENT_ERROR_STARTFAIL ((jint)102) /* No agentmain method or agentmain failed */
+
+/*
+ * This will be called once each time a tool attaches to the VM and loads
+ * the JPLIS library.
+ */
+JNIEXPORT jint JNICALL
+DEF_Agent_OnAttach(JavaVM* vm, char *args, void * reserved) {
+ JPLISInitializationError initerror = JPLIS_INIT_ERROR_NONE;
+ jint result = JNI_OK;
+ JPLISAgent * agent = NULL;
+ JNIEnv * jni_env = NULL;
+
+ /*
+ * Need JNIEnv - guaranteed to be called from thread that is already
+ * attached to VM
+ */
+ result = (*vm)->GetEnv(vm, (void**)&jni_env, JNI_VERSION_1_2);
+ jplis_assert(result==JNI_OK);
+
+ initerror = createNewJPLISAgent(vm, &agent);
+ if ( initerror == JPLIS_INIT_ERROR_NONE ) {
+ int oldLen, newLen;
+ char * jarfile;
+ char * options;
+ jarAttribute* attributes;
+ char * agentClass;
+ char * bootClassPath;
+ jboolean success;
+
+ /*
+ * Parse <jarfile>[=options] into jarfile and options
+ */
+ if (parseArgumentTail(args, &jarfile, &options) != 0) {
+ return JNI_ENOMEM;
+ }
+
+ /*
+ * Open the JAR file and parse the manifest
+ */
+ attributes = readAttributes( jarfile );
+ if (attributes == NULL) {
+ fprintf(stderr, "Error opening zip file or JAR manifest missing: %s\n", jarfile);
+ free(jarfile);
+ if (options != NULL) free(options);
+ return AGENT_ERROR_BADJAR;
+ }
+
+ agentClass = getAttribute(attributes, "Agent-Class");
+ if (agentClass == NULL) {
+ fprintf(stderr, "Failed to find Agent-Class manifest attribute from %s\n",
+ jarfile);
+ free(jarfile);
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ return AGENT_ERROR_BADJAR;
+ }
+
+ /*
+ * Add the jarfile to the system class path
+ */
+ if (appendClassPath(agent, jarfile)) {
+ fprintf(stderr, "Unable to add %s to system class path "
+ "- not supported by system class loader or configuration error!\n",
+ jarfile);
+ free(jarfile);
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ return AGENT_ERROR_NOTONCP;
+ }
+
+ /*
+ * The value of the Agent-Class attribute becomes the agent
+ * class name. The manifest is in UTF8 so need to convert to
+ * modified UTF8 (see JNI spec).
+ */
+ oldLen = (int)strlen(agentClass);
+ newLen = modifiedUtf8LengthOfUtf8(agentClass, oldLen);
+ if (newLen == oldLen) {
+ agentClass = strdup(agentClass);
+ } else {
+ char* str = (char*)malloc( newLen+1 );
+ if (str != NULL) {
+ convertUtf8ToModifiedUtf8(agentClass, oldLen, str, newLen);
+ }
+ agentClass = str;
+ }
+ if (agentClass == NULL) {
+ free(jarfile);
+ if (options != NULL) free(options);
+ freeAttributes(attributes);
+ return JNI_ENOMEM;
+ }
+
+ /*
+ * If the Boot-Class-Path attribute is specified then we process
+ * each URL - in the live phase only JAR files will be added.
+ */
+ bootClassPath = getAttribute(attributes, "Boot-Class-Path");
+ if (bootClassPath != NULL) {
+ appendBootClassPath(agent, jarfile, bootClassPath);
+ }
+
+ /*
+ * Convert JAR attributes into agent capabilities
+ */
+ convertCapabilityAttributes(attributes, agent);
+
+ /*
+ * Create the java.lang.instrument.Instrumentation instance
+ */
+ success = createInstrumentationImpl(jni_env, agent);
+ jplis_assert(success);
+
+ /*
+ * Turn on the ClassFileLoadHook.
+ */
+ if (success) {
+ success = setLivePhaseEventHandlers(agent);
+ jplis_assert(success);
+ }
+
+ /*
+ * Start the agent
+ */
+ if (success) {
+ success = startJavaAgent(agent,
+ jni_env,
+ agentClass,
+ options,
+ agent->mAgentmainCaller);
+ }
+
+ if (!success) {
+ fprintf(stderr, "Agent failed to start!\n");
+ result = AGENT_ERROR_STARTFAIL;
+ }
+
+ /*
+ * Clean-up
+ */
+ free(jarfile);
+ if (options != NULL) free(options);
+ free(agentClass);
+ freeAttributes(attributes);
+ }
+
+ return result;
+}
+
+
+JNIEXPORT void JNICALL
+DEF_Agent_OnUnload(JavaVM *vm) {
+}
+
+/**
+ * Invoked by the java launcher to load an agent in the main executable JAR.
+ * The Launcher-Agent-Class attribute in the main manifest of the JAR file
+ * is the agent class.
+ *
+ * Returns JNI_OK if the agent is loaded and initialized; JNI_ERR if this
+ * function fails, possibly with a pending exception.
+ */
+jint loadAgent(JNIEnv* env, jstring path) {
+ JavaVM* vm;
+ JPLISAgent* agent;
+ const char* jarfile = NULL;
+ jarAttribute* attributes = NULL;
+ char* agentClass = NULL;
+ char* bootClassPath;
+ int oldLen, newLen;
+ jint result = JNI_ERR;
+
+ if ((*env)->GetJavaVM(env, &vm) < 0) {
+ return JNI_ERR;
+ }
+
+ // create JPLISAgent with JVMTI environment
+ if (createNewJPLISAgent(vm, &agent) != JPLIS_INIT_ERROR_NONE) {
+ return JNI_ERR;
+ }
+
+ // get path to JAR file as UTF-8 string
+ jarfile = (*env)->GetStringUTFChars(env, path, NULL);
+ if (jarfile == NULL) {
+ return JNI_ERR;
+ }
+
+ // read the attributes in the main section of JAR manifest
+ attributes = readAttributes(jarfile);
+ if (attributes == NULL) {
+ goto releaseAndReturn;
+ }
+
+ // Launcher-Agent-Class is required
+ agentClass = getAttribute(attributes, "Launcher-Agent-Class");
+ if (agentClass == NULL) {
+ goto releaseAndReturn;
+ }
+
+ // The value of Launcher-Agent-Class is in UTF-8, convert it to modified UTF-8
+ oldLen = (int) strlen(agentClass);
+ newLen = modifiedUtf8LengthOfUtf8(agentClass, oldLen);
+ if (newLen == oldLen) {
+ agentClass = strdup(agentClass);
+ } else {
+ char* str = (char*) malloc(newLen + 1);
+ if (str != NULL) {
+ convertUtf8ToModifiedUtf8(agentClass, oldLen, str, newLen);
+ }
+ agentClass = str;
+ }
+ if (agentClass == NULL) {
+ jthrowable oome = createThrowable(env, "java/lang/OutOfMemoryError", NULL);
+ if (oome != NULL) (*env)->Throw(env, oome);
+ goto releaseAndReturn;
+ }
+
+ // Boot-Class-Path
+ bootClassPath = getAttribute(attributes, "Boot-Class-Path");
+ if (bootClassPath != NULL) {
+ appendBootClassPath(agent, jarfile, bootClassPath);
+ }
+
+ // Can-XXXX capabilities
+ convertCapabilityAttributes(attributes, agent);
+
+ // Create the java.lang.instrument.Instrumentation object
+ if (!createInstrumentationImpl(env, agent)) {
+ goto releaseAndReturn;
+ }
+
+ // Enable the ClassFileLoadHook
+ if (!setLivePhaseEventHandlers(agent)) {
+ goto releaseAndReturn;
+ }
+
+ // invoke the agentmain method
+ if (!startJavaAgent(agent, env, agentClass, "", agent->mAgentmainCaller)) {
+ goto releaseAndReturn;
+ }
+
+ // initialization complete
+ result = JNI_OK;
+
+ releaseAndReturn:
+ if (agentClass != NULL) {
+ free(agentClass);
+ }
+ if (attributes != NULL) {
+ freeAttributes(attributes);
+ }
+ if (jarfile != NULL) {
+ (*env)->ReleaseStringUTFChars(env, path, jarfile);
+ }
+
+ return result;
+}
+
+/*
+ * JVMTI callback support
+ *
+ * We have two "stages" of callback support.
+ * At OnLoad time, we install a VMInit handler.
+ * When the VMInit handler runs, we remove the VMInit handler and install a
+ * ClassFileLoadHook handler.
+ */
+
+void JNICALL
+eventHandlerVMInit( jvmtiEnv * jvmtienv,
+ JNIEnv * jnienv,
+ jthread thread) {
+ JPLISEnvironment * environment = NULL;
+ jboolean success = JNI_FALSE;
+
+ environment = getJPLISEnvironment(jvmtienv);
+
+ /* process the premain calls on the all the JPL agents */
+ if ( environment != NULL ) {
+ jthrowable outstandingException = NULL;
+ /*
+ * Add the jarfile to the system class path
+ */
+ JPLISAgent * agent = environment->mAgent;
+ if (appendClassPath(agent, agent->mJarfile)) {
+ fprintf(stderr, "Unable to add %s to system class path - "
+ "the system class loader does not define the "
+ "appendToClassPathForInstrumentation method or the method failed\n",
+ agent->mJarfile);
+ free((void *)agent->mJarfile);
+ abortJVM(jnienv, JPLIS_ERRORMESSAGE_CANNOTSTART);
+ }
+ free((void *)agent->mJarfile);
+ agent->mJarfile = NULL;
+
+ outstandingException = preserveThrowable(jnienv);
+ success = processJavaStart( environment->mAgent,
+ jnienv);
+ restoreThrowable(jnienv, outstandingException);
+ }
+
+ /* if we fail to start cleanly, bring down the JVM */
+ if ( !success ) {
+ abortJVM(jnienv, JPLIS_ERRORMESSAGE_CANNOTSTART);
+ }
+}
+
+void JNICALL
+eventHandlerClassFileLoadHook( jvmtiEnv * jvmtienv,
+ JNIEnv * jnienv,
+ jclass class_being_redefined,
+ jobject loader,
+ const char* name,
+ jobject protectionDomain,
+ jint class_data_len,
+ const unsigned char* class_data,
+ jint* new_class_data_len,
+ unsigned char** new_class_data) {
+ JPLISEnvironment * environment = NULL;
+
+ environment = getJPLISEnvironment(jvmtienv);
+
+ /* if something is internally inconsistent (no agent), just silently return without touching the buffer */
+ if ( environment != NULL ) {
+ jthrowable outstandingException = preserveThrowable(jnienv);
+ transformClassFile( environment->mAgent,
+ jnienv,
+ loader,
+ name,
+ class_being_redefined,
+ protectionDomain,
+ class_data_len,
+ class_data,
+ new_class_data_len,
+ new_class_data,
+ environment->mIsRetransformer);
+ restoreThrowable(jnienv, outstandingException);
+ }
+}
+
+
+
+
+/*
+ * URLs in Boot-Class-Path attributes are separated by one or more spaces.
+ * This function splits the attribute value into a list of path segments.
+ * The attribute value is in UTF8 but cannot contain NUL. Also non US-ASCII
+ * characters must be escaped (URI syntax) so safe to iterate through the
+ * value as a C string.
+ */
+static void
+splitPathList(const char* str, int* pathCount, char*** paths) {
+ int count = 0;
+ char** segments = NULL;
+ char** new_segments;
+ char* c = (char*) str;
+ while (*c != '\0') {
+ while (*c == ' ') c++; /* skip leading spaces */
+ if (*c == '\0') {
+ break;
+ }
+ new_segments = (char**)realloc(segments, (count+1)*sizeof(char*));
+ if (new_segments == NULL) {
+ jplis_assert(0);
+ free(segments);
+ count = 0;
+ segments = NULL;
+ break;
+ }
+ segments = new_segments;
+ segments[count++] = c;
+ c = strchr(c, ' ');
+ if (c == NULL) {
+ break;
+ }
+ *c = '\0';
+ c++;
+ }
+ *pathCount = count;
+ *paths = segments;
+}
+
+
+/* URI path decoding - ported from src/share/classes/java/net/URI.java */
+
+static int
+decodeNibble(char c) {
+ if ((c >= '0') && (c <= '9'))
+ return c - '0';
+ if ((c >= 'a') && (c <= 'f'))
+ return c - 'a' + 10;
+ if ((c >= 'A') && (c <= 'F'))
+ return c - 'A' + 10;
+ return -1;
+}
+
+static int
+decodeByte(char c1, char c2) {
+ return (((decodeNibble(c1) & 0xf) << 4) | ((decodeNibble(c2) & 0xf) << 0));
+}
+
+/*
+ * Evaluates all escapes in s. Assumes that escapes are well-formed
+ * syntactically, i.e., of the form %XX.
+ * If the path does not require decoding the original path is
+ * returned. Otherwise the decoded path (heap allocated) is returned,
+ * along with the length of the decoded path. Note that the return
+ * string will not be null terminated after decoding.
+ */
+static
+char *decodePath(const char *s, int* decodedLen) {
+ int n;
+ char *result;
+ char *resultp;
+ int c;
+ int i;
+
+ n = (int)strlen(s);
+ if (n == 0) {
+ *decodedLen = 0;
+ return (char*)s;
+ }
+ if (strchr(s, '%') == NULL) {
+ *decodedLen = n;
+ return (char*)s; /* no escapes, we are done */
+ }
+
+ resultp = result = calloc(n+1, 1);
+ c = s[0];
+ for (i = 0; i < n;) {
+ if (c != '%') {
+ *resultp++ = c;
+ if (++i >= n)
+ break;
+ c = s[i];
+ continue;
+ }
+ for (;;) {
+ char b1 = s[++i];
+ char b2 = s[++i];
+ int decoded = decodeByte(b1, b2);
+ *resultp++ = decoded;
+ if (++i >= n)
+ break;
+ c = s[i];
+ if (c != '%')
+ break;
+ }
+ }
+ *decodedLen = (int)(resultp - result);
+ return result; // not null terminated.
+}
+
+/*
+ * Append the given jar file to the system class path. This should succeed in the
+ * onload phase but may fail in the live phase if the system class loader doesn't
+ * support appending to the class path.
+ */
+static int
+appendClassPath( JPLISAgent* agent,
+ const char* jarfile ) {
+ jvmtiEnv* jvmtienv = jvmti(agent);
+ jvmtiError jvmtierr;
+
+ jvmtierr = (*jvmtienv)->AddToSystemClassLoaderSearch(jvmtienv, jarfile);
+ check_phase_ret_1(jvmtierr);
+
+ switch (jvmtierr) {
+ case JVMTI_ERROR_NONE :
+ return 0;
+ case JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED :
+ fprintf(stderr, "System class loader does not define "
+ "the appendToClassPathForInstrumentation method\n");
+ break;
+ default:
+ fprintf(stderr, "Unexpected error (%d) returned by "
+ "AddToSystemClassLoaderSearch\n", jvmtierr);
+ break;
+ }
+ return -1;
+}
+
+
+/*
+ * res = func, free'ing the previous value of 'res' if function
+ * returns a new result.
+ */
+#define TRANSFORM(res,func) { \
+ char* tmp = func; \
+ if (tmp != res) { \
+ free(res); \
+ res = tmp; \
+ } \
+ jplis_assert((void*)res != (void*)NULL); \
+}
+
+/**
+ * Convert a pathname to canonical form.
+ * This method is exported from libjava.
+ */
+extern int
+Canonicalize(JNIEnv *unused, char *orig, char *out, int len);
+
+
+/*
+ * This function takes the value of the Boot-Class-Path attribute,
+ * splits it into the individual path segments, and then combines it
+ * with the path to the jar file to create the path to be added
+ * to the bootclasspath.
+ *
+ * Each individual path segment starts out as a UTF8 string. Additionally
+ * as the path is specified to use URI path syntax all non US-ASCII
+ * characters are escaped. Once the URI path is decoded we get a UTF8
+ * string which must then be converted to the platform encoding (as it
+ * will be combined with the platform path of the jar file). Once
+ * converted it is then normalized (remove duplicate slashes, etc.).
+ * If the resulting path is an absolute path (starts with a slash for
+ * example) then the path will be added to the bootclasspath. Otherwise
+ * if it's not absolute then we get the canoncial path of the agent jar
+ * file and then resolve the path in the context of the base path of
+ * the agent jar.
+ */
+static void
+appendBootClassPath( JPLISAgent* agent,
+ const char* jarfile,
+ const char* pathList ) {
+ char canonicalPath[MAXPATHLEN];
+ char *parent = NULL;
+ int haveBasePath = 0;
+
+ int count, i;
+ char **paths;
+ jvmtiEnv* jvmtienv = jvmti(agent);
+ jvmtiError jvmtierr;
+
+ /*
+ * Split the attribute value into the individual path segments
+ * and process each in sequence
+ */
+ splitPathList(pathList, &count, &paths);
+
+ for (i=0; i<count; i++) {
+ int len;
+ char* path;
+ char* pos;
+
+ /*
+ * The path segment at this point is a pointer into the attribute
+ * value. As it will go through a number of transformation (tossing away
+ * the previous results as we go along) it make it easier if the path
+ * starts out as a heap allocated string.
+ */
+ path = strdup(paths[i]);
+ jplis_assert(path != (char*)NULL);
+
+ /*
+ * The attribute is specified to be a list of relative URIs so in theory
+ * there could be a query component - if so, get rid of it.
+ */
+ pos = strchr(path, '?');
+ if (pos != NULL) {
+ *pos = '\0';
+ }
+
+ /*
+ * Check for characters that are not allowed in the path component of
+ * a URI.
+ */
+ if (validatePathChars(path)) {
+ fprintf(stderr, "WARNING: illegal character in Boot-Class-Path value: %s\n",
+ path);
+ free(path);
+ continue;
+ }
+
+
+ /*
+ * Next decode any escaped characters. The result is a UTF8 string.
+ */
+ TRANSFORM(path, decodePath(path,&len));
+
+ /*
+ * Convert to the platform encoding
+ */
+ {
+ char platform[MAXPATHLEN];
+ int new_len = convertUft8ToPlatformString(path, len, platform, MAXPATHLEN);
+ free(path);
+ if (new_len < 0) {
+ /* bogus value - exceeds maximum path size or unable to convert */
+ continue;
+ }
+ path = strdup(platform);
+ jplis_assert(path != (char*)NULL);
+ }
+
+ /*
+ * Post-process the URI path - needed on Windows to transform
+ * /c:/foo to c:/foo.
+ */
+ TRANSFORM(path, fromURIPath(path));
+
+ /*
+ * Normalize the path - no duplicate slashes (except UNCs on Windows), trailing
+ * slash removed.
+ */
+ TRANSFORM(path, normalize(path));
+
+ /*
+ * If the path is an absolute path then add to the bootclassloader
+ * search path. Otherwise we get the canonical path of the agent jar
+ * and then use its base path (directory) to resolve the given path
+ * segment.
+ *
+ * NOTE: JVMTI is specified to use modified UTF8 strings (like JNI).
+ * In 1.5.0 the AddToBootstrapClassLoaderSearch takes a platform string
+ * - see 5049313.
+ */
+ if (isAbsolute(path)) {
+ jvmtierr = (*jvmtienv)->AddToBootstrapClassLoaderSearch(jvmtienv, path);
+ } else {
+ char* resolved;
+
+ if (!haveBasePath) {
+ /* Use NULL as the JNIEnv since we know that Canonicalize does not use it. */
+ if (Canonicalize(NULL, (char*)jarfile, canonicalPath, sizeof(canonicalPath)) != 0) {
+ fprintf(stderr, "WARNING: unable to canonicalize %s\n", jarfile);
+ free(path);
+ continue;
+ }
+ parent = basePath(canonicalPath);
+ jplis_assert(parent != (char*)NULL);
+ haveBasePath = 1;
+ }
+
+ resolved = resolve(parent, path);
+ jvmtierr = (*jvmtienv)->AddToBootstrapClassLoaderSearch(jvmtienv, resolved);
+ }
+
+ /* print warning if boot class path not updated */
+ if (jvmtierr != JVMTI_ERROR_NONE) {
+ check_phase_blob_ret(jvmtierr, free(path));
+
+ fprintf(stderr, "WARNING: %s not added to bootstrap class loader search: ", path);
+ switch (jvmtierr) {
+ case JVMTI_ERROR_ILLEGAL_ARGUMENT :
+ fprintf(stderr, "Illegal argument or not JAR file\n");
+ break;
+ default:
+ fprintf(stderr, "Unexpected error: %d\n", jvmtierr);
+ }
+ }
+
+ /* finished with the path */
+ free(path);
+ }
+
+
+ /* clean-up */
+ if (haveBasePath && parent != canonicalPath) {
+ free(parent);
+ }
+}