1 /*
   2  * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 
  29 #include "jni.h"
  30 #include "jni_util.h"
  31 #include "jlong.h"
  32 #include "jvm.h"
  33 #include "java_lang_ClassLoader.h"
  34 #include "java_lang_ClassLoader_NativeLibrary.h"

  35 
  36 /* defined in libverify.so/verify.dll (src file common/check_format.c) */
  37 extern jboolean VerifyClassname(char *utf_name, jboolean arrayAllowed);
  38 extern jboolean VerifyFixClassname(char *utf_name);
  39 
  40 static JNINativeMethod methods[] = {
  41     {"retrieveDirectives",  "()Ljava/lang/AssertionStatusDirectives;", (void *)&JVM_AssertionStatusDirectives}
  42 };
  43 
  44 JNIEXPORT void JNICALL
  45 Java_java_lang_ClassLoader_registerNatives(JNIEnv *env, jclass cls)
  46 {
  47     (*env)->RegisterNatives(env, cls, methods,
  48                             sizeof(methods)/sizeof(JNINativeMethod));
  49 }
  50 
  51 /* Convert java string to UTF char*. Use local buffer if possible,
  52    otherwise malloc new memory. Returns null IFF malloc failed. */
  53 static char*
  54 getUTF(JNIEnv *env, jstring str, char* localBuf, int bufSize)
  55 {
  56     char* utfStr = NULL;
  57 
  58     int len = (*env)->GetStringUTFLength(env, str);
  59     int unicode_len = (*env)->GetStringLength(env, str);
  60     if (len >= bufSize) {
  61         utfStr = malloc(len + 1);
  62         if (utfStr == NULL) {
  63             JNU_ThrowOutOfMemoryError(env, NULL);
  64             return NULL;
  65         }
  66     } else {
  67         utfStr = localBuf;
  68     }
  69     (*env)->GetStringUTFRegion(env, str, 0, unicode_len, utfStr);
  70 
  71     return utfStr;
  72 }
  73 
  74 // The existence or signature of this method is not guaranteed since it
  75 // supports a private method.  This method will be changed in 1.7.
  76 JNIEXPORT jclass JNICALL
  77 Java_java_lang_ClassLoader_defineClass0(JNIEnv *env,
  78                                         jobject loader,
  79                                         jstring name,
  80                                         jbyteArray data,
  81                                         jint offset,
  82                                         jint length,
  83                                         jobject pd)
  84 {
  85     return Java_java_lang_ClassLoader_defineClass1(env, loader, name, data, offset,
  86                                                    length, pd, NULL);
  87 }
  88 
  89 JNIEXPORT jclass JNICALL
  90 Java_java_lang_ClassLoader_defineClass1(JNIEnv *env,
  91                                         jobject loader,
  92                                         jstring name,
  93                                         jbyteArray data,
  94                                         jint offset,
  95                                         jint length,
  96                                         jobject pd,
  97                                         jstring source)
  98 {
  99     jbyte *body;
 100     char *utfName;
 101     jclass result = 0;
 102     char buf[128];
 103     char* utfSource;
 104     char sourceBuf[1024];
 105 
 106     if (data == NULL) {
 107         JNU_ThrowNullPointerException(env, 0);
 108         return 0;
 109     }
 110 
 111     /* Work around 4153825. malloc crashes on Solaris when passed a
 112      * negative size.
 113      */
 114     if (length < 0) {
 115         JNU_ThrowArrayIndexOutOfBoundsException(env, 0);
 116         return 0;
 117     }
 118 
 119     body = (jbyte *)malloc(length);
 120 
 121     if (body == 0) {
 122         JNU_ThrowOutOfMemoryError(env, 0);
 123         return 0;
 124     }
 125 
 126     (*env)->GetByteArrayRegion(env, data, offset, length, body);
 127 
 128     if ((*env)->ExceptionOccurred(env))
 129         goto free_body;
 130 
 131     if (name != NULL) {
 132         utfName = getUTF(env, name, buf, sizeof(buf));
 133         if (utfName == NULL) {
 134             JNU_ThrowOutOfMemoryError(env, NULL);
 135             goto free_body;
 136         }
 137         VerifyFixClassname(utfName);
 138     } else {
 139         utfName = NULL;
 140     }
 141 
 142     if (source != NULL) {
 143         utfSource = getUTF(env, source, sourceBuf, sizeof(sourceBuf));
 144         if (utfSource == NULL) {
 145             JNU_ThrowOutOfMemoryError(env, NULL);
 146             goto free_utfName;
 147         }
 148     } else {
 149         utfSource = NULL;
 150     }
 151     result = JVM_DefineClassWithSource(env, utfName, loader, body, length, pd, utfSource);
 152 
 153     if (utfSource && utfSource != sourceBuf)
 154         free(utfSource);
 155 
 156  free_utfName:
 157     if (utfName && utfName != buf)
 158         free(utfName);
 159 
 160  free_body:
 161     free(body);
 162     return result;
 163 }
 164 
 165 JNIEXPORT jclass JNICALL
 166 Java_java_lang_ClassLoader_defineClass2(JNIEnv *env,
 167                                         jobject loader,
 168                                         jstring name,
 169                                         jobject data,
 170                                         jint offset,
 171                                         jint length,
 172                                         jobject pd,
 173                                         jstring source)
 174 {
 175     jbyte *body;
 176     char *utfName;
 177     jclass result = 0;
 178     char buf[128];
 179     char* utfSource;
 180     char sourceBuf[1024];
 181 
 182     assert(data != NULL); // caller fails if data is null.
 183     assert(length >= 0);  // caller passes ByteBuffer.remaining() for length, so never neg.
 184     // caller passes ByteBuffer.position() for offset, and capacity() >= position() + remaining()
 185     assert((*env)->GetDirectBufferCapacity(env, data) >= (offset + length));
 186 
 187     body = (*env)->GetDirectBufferAddress(env, data);
 188 
 189     if (body == 0) {
 190         JNU_ThrowNullPointerException(env, 0);
 191         return 0;
 192     }
 193 
 194     body += offset;
 195 
 196     if (name != NULL) {
 197         utfName = getUTF(env, name, buf, sizeof(buf));
 198         if (utfName == NULL) {
 199             JNU_ThrowOutOfMemoryError(env, NULL);
 200             return result;
 201         }
 202         VerifyFixClassname(utfName);
 203     } else {
 204         utfName = NULL;
 205     }
 206 
 207     if (source != NULL) {
 208         utfSource = getUTF(env, source, sourceBuf, sizeof(sourceBuf));
 209         if (utfSource == NULL) {
 210             JNU_ThrowOutOfMemoryError(env, NULL);
 211             goto free_utfName;
 212         }
 213     } else {
 214         utfSource = NULL;
 215     }
 216     result = JVM_DefineClassWithSource(env, utfName, loader, body, length, pd, utfSource);
 217 
 218     if (utfSource && utfSource != sourceBuf)
 219         free(utfSource);
 220 
 221  free_utfName:
 222     if (utfName && utfName != buf)
 223         free(utfName);
 224 
 225     return result;
 226 }
 227 
 228 JNIEXPORT void JNICALL
 229 Java_java_lang_ClassLoader_resolveClass0(JNIEnv *env, jobject this,
 230                                          jclass cls)
 231 {
 232     if (cls == NULL) {
 233         JNU_ThrowNullPointerException(env, 0);
 234         return;
 235     }
 236 
 237     JVM_ResolveClass(env, cls);
 238 }
 239 
 240 /*
 241  * Returns NULL if class not found.
 242  */
 243 JNIEXPORT jclass JNICALL
 244 Java_java_lang_ClassLoader_findBootstrapClass(JNIEnv *env, jobject loader,
 245                                               jstring classname)
 246 {
 247     char *clname;
 248     jclass cls = 0;
 249     char buf[128];
 250 
 251     if (classname == NULL) {
 252         return 0;
 253     }
 254 
 255     clname = getUTF(env, classname, buf, sizeof(buf));
 256     if (clname == NULL) {
 257         JNU_ThrowOutOfMemoryError(env, NULL);
 258         return NULL;
 259     }
 260     VerifyFixClassname(clname);
 261 
 262     if (!VerifyClassname(clname, JNI_TRUE)) {  /* expects slashed name */
 263         goto done;
 264     }
 265 
 266     cls = JVM_FindClassFromBootLoader(env, clname);
 267 
 268  done:
 269     if (clname != buf) {
 270         free(clname);
 271     }
 272 
 273     return cls;
 274 }
 275 
 276 JNIEXPORT jclass JNICALL
 277 Java_java_lang_ClassLoader_findLoadedClass0(JNIEnv *env, jobject loader,
 278                                            jstring name)
 279 {
 280     if (name == NULL) {
 281         return 0;
 282     } else {
 283         return JVM_FindLoadedClass(env, loader, name);
 284     }
 285 }
 286 
 287 static jfieldID handleID;
 288 static jfieldID jniVersionID;


 289 
 290 static jboolean initIDs(JNIEnv *env)
 291 {
 292     if (handleID == 0) {
 293         jclass this =
 294             (*env)->FindClass(env, "java/lang/ClassLoader$NativeLibrary");
 295         if (this == 0)
 296             return JNI_FALSE;
 297         handleID = (*env)->GetFieldID(env, this, "handle", "J");
 298         if (handleID == 0)
 299             return JNI_FALSE;
 300         jniVersionID = (*env)->GetFieldID(env, this, "jniVersion", "I");
 301         if (jniVersionID == 0)
 302             return JNI_FALSE;




 303     }
 304     return JNI_TRUE;
 305 }
 306 
 307 typedef jint (JNICALL *JNI_OnLoad_t)(JavaVM *, void *);
 308 typedef void (JNICALL *JNI_OnUnload_t)(JavaVM *, void *);
 309 
 310 /*


















































 311  * Class:     java_lang_ClassLoader_NativeLibrary
 312  * Method:    load
 313  * Signature: (Ljava/lang/String;)J
 314  */
 315 JNIEXPORT void JNICALL
 316 Java_java_lang_ClassLoader_00024NativeLibrary_load
 317   (JNIEnv *env, jobject this, jstring name)
 318 {
 319     const char *cname;
 320     jint jniVersion;
 321     jthrowable cause;
 322     void * handle;
 323 
 324     if (!initIDs(env))
 325         return;
 326 
 327     cname = JNU_GetStringPlatformChars(env, name, 0);
 328     if (cname == 0)
 329         return;
 330     handle = JVM_LoadLibrary(cname);
 331     if (handle) {
 332         const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS;
 333         JNI_OnLoad_t JNI_OnLoad;
 334         unsigned int i;
 335         for (i = 0; i < sizeof(onLoadSymbols) / sizeof(char *); i++) {
 336             JNI_OnLoad = (JNI_OnLoad_t)
 337                 JVM_FindLibraryEntry(handle, onLoadSymbols[i]);
 338             if (JNI_OnLoad) {
 339                 break;
 340             }
 341         }
 342         if (JNI_OnLoad) {
 343             JavaVM *jvm;
 344             (*env)->GetJavaVM(env, &jvm);
 345             jniVersion = (*JNI_OnLoad)(jvm, NULL);
 346         } else {
 347             jniVersion = 0x00010001;
 348         }
 349 
 350         cause = (*env)->ExceptionOccurred(env);
 351         if (cause) {
 352             (*env)->ExceptionClear(env);
 353             (*env)->Throw(env, cause);
 354             JVM_UnloadLibrary(handle);
 355             goto done;
 356         }
 357 
 358         if (!JVM_IsSupportedJNIVersion(jniVersion)) {

 359             char msg[256];
 360             jio_snprintf(msg, sizeof(msg),
 361                          "unsupported JNI version 0x%08X required by %s",
 362                          jniVersion, cname);
 363             JNU_ThrowByName(env, "java/lang/UnsatisfiedLinkError", msg);
 364             JVM_UnloadLibrary(handle);
 365             goto done;
 366         }
 367         (*env)->SetIntField(env, this, jniVersionID, jniVersion);
 368     } else {
 369         cause = (*env)->ExceptionOccurred(env);
 370         if (cause) {
 371             (*env)->ExceptionClear(env);
 372             (*env)->SetLongField(env, this, handleID, (jlong)0);
 373             (*env)->Throw(env, cause);
 374         }
 375         goto done;
 376     }
 377     (*env)->SetLongField(env, this, handleID, ptr_to_jlong(handle));

 378 
 379  done:
 380     JNU_ReleaseStringPlatformChars(env, name, cname);
 381 }
 382 
 383 /*
 384  * Class:     java_lang_ClassLoader_NativeLibrary
 385  * Method:    unload
 386  * Signature: ()V
 387  */
 388 JNIEXPORT void JNICALL
 389 Java_java_lang_ClassLoader_00024NativeLibrary_unload
 390   (JNIEnv *env, jobject this)
 391 {
 392     const char *onUnloadSymbols[] = JNI_ONUNLOAD_SYMBOLS;
 393     void *handle;
 394     JNI_OnUnload_t JNI_OnUnload;
 395     unsigned int i;
 396 
 397     if (!initIDs(env))
 398         return;
 399 
 400     handle = jlong_to_ptr((*env)->GetLongField(env, this, handleID));
 401     for (i = 0; i < sizeof(onUnloadSymbols) / sizeof(char *); i++) {
 402         JNI_OnUnload = (JNI_OnUnload_t )
 403             JVM_FindLibraryEntry(handle, onUnloadSymbols[i]);
 404         if (JNI_OnUnload) {
 405             break;
 406         }
 407     }
 408 



 409     if (JNI_OnUnload) {
 410         JavaVM *jvm;
 411         (*env)->GetJavaVM(env, &jvm);
 412         (*JNI_OnUnload)(jvm, NULL);
 413     }
 414     JVM_UnloadLibrary(handle);

 415 }
 416 
 417 /*
 418  * Class:     java_lang_ClassLoader_NativeLibrary
 419  * Method:    find
 420  * Signature: (Ljava/lang/String;J)J
 421  */
 422 JNIEXPORT jlong JNICALL
 423 Java_java_lang_ClassLoader_00024NativeLibrary_find
 424   (JNIEnv *env, jobject this, jstring name)
 425 {
 426     jlong handle;
 427     const char *cname;
 428     jlong res;
 429 
 430     if (!initIDs(env))
 431         return jlong_zero;
 432 
 433     handle = (*env)->GetLongField(env, this, handleID);
 434     cname = (*env)->GetStringUTFChars(env, name, 0);
 435     if (cname == 0)
 436         return jlong_zero;
 437     res = ptr_to_jlong(JVM_FindLibraryEntry(jlong_to_ptr(handle), cname));
 438     (*env)->ReleaseStringUTFChars(env, name, cname);
 439     return res;
 440 }
 441 
 442 JNIEXPORT jobject JNICALL
 443 Java_java_lang_ClassLoader_getCaller(JNIEnv *env, jclass cls, jint index)
 444 {
 445     jobjectArray jcallerStack;
 446     int len;
 447 
 448     jcallerStack = JVM_GetClassContext(env);
 449     if ((*env)->ExceptionCheck(env)) {
 450         return NULL;
 451     }
 452     len = (*env)->GetArrayLength(env, jcallerStack);
 453     if (index < len) {
 454         return (*env)->GetObjectArrayElement(env, jcallerStack, index);
 455     }
 456     return NULL;
 457 }
 458 


























































--- EOF ---