1 /* 2 * Copyright (c) 1997, 2016, 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 <string.h> 28 29 #include "jvm.h" 30 #include "jni.h" 31 #include "jni_util.h" 32 33 /* Due to a bug in the win32 C runtime library strings 34 * such as "z:" need to be appended with a "." so we 35 * must allocate at least 4 bytes to allow room for 36 * this expansion. See 4235353 for details. 37 */ 38 #define MALLOC_MIN4(len) ((char *)malloc((len) + 1 < 4 ? 4 : (len) + 1)) 39 40 /** 41 * Throw a Java exception by name. Similar to SignalError. 42 */ 43 JNIEXPORT void JNICALL 44 JNU_ThrowByName(JNIEnv *env, const char *name, const char *msg) 45 { 46 jclass cls = (*env)->FindClass(env, name); 47 48 if (cls != 0) /* Otherwise an exception has already been thrown */ 49 (*env)->ThrowNew(env, cls, msg); 50 } 51 52 /* JNU_Throw common exceptions */ 53 54 JNIEXPORT void JNICALL 55 JNU_ThrowNullPointerException(JNIEnv *env, const char *msg) 56 { 57 JNU_ThrowByName(env, JNU_JAVAPKG "NullPointerException", msg); 58 } 59 60 JNIEXPORT void JNICALL 61 JNU_ThrowArrayIndexOutOfBoundsException(JNIEnv *env, const char *msg) 62 { 63 JNU_ThrowByName(env, JNU_JAVAPKG "ArrayIndexOutOfBoundsException", msg); 64 } 65 66 JNIEXPORT void JNICALL 67 JNU_ThrowOutOfMemoryError(JNIEnv *env, const char *msg) 68 { 69 JNU_ThrowByName(env, JNU_JAVAPKG "OutOfMemoryError", msg); 70 } 71 72 JNIEXPORT void JNICALL 73 JNU_ThrowIllegalArgumentException(JNIEnv *env, const char *msg) 74 { 75 JNU_ThrowByName(env, JNU_JAVAPKG "IllegalArgumentException", msg); 76 } 77 78 JNIEXPORT void JNICALL 79 JNU_ThrowIllegalAccessError(JNIEnv *env, const char *msg) 80 { 81 JNU_ThrowByName(env, JNU_JAVAPKG "IllegalAccessError", msg); 82 } 83 84 JNIEXPORT void JNICALL 85 JNU_ThrowIllegalAccessException(JNIEnv *env, const char *msg) 86 { 87 JNU_ThrowByName(env, JNU_JAVAPKG "IllegalAccessException", msg); 88 } 89 90 JNIEXPORT void JNICALL 91 JNU_ThrowInternalError(JNIEnv *env, const char *msg) 92 { 93 JNU_ThrowByName(env, JNU_JAVAPKG "InternalError", msg); 94 } 95 96 JNIEXPORT void JNICALL 97 JNU_ThrowNoSuchFieldException(JNIEnv *env, const char *msg) 98 { 99 JNU_ThrowByName(env, JNU_JAVAPKG "NoSuchFieldException", msg); 100 } 101 102 JNIEXPORT void JNICALL 103 JNU_ThrowNoSuchMethodException(JNIEnv *env, const char *msg) 104 { 105 JNU_ThrowByName(env, JNU_JAVAPKG "NoSuchMethodException", msg); 106 } 107 108 JNIEXPORT void JNICALL 109 JNU_ThrowClassNotFoundException(JNIEnv *env, const char *msg) 110 { 111 JNU_ThrowByName(env, JNU_JAVAPKG "ClassNotFoundException", msg); 112 } 113 114 JNIEXPORT void JNICALL 115 JNU_ThrowNumberFormatException(JNIEnv *env, const char *msg) 116 { 117 JNU_ThrowByName(env, JNU_JAVAPKG "NumberFormatException", msg); 118 } 119 120 JNIEXPORT void JNICALL 121 JNU_ThrowIOException(JNIEnv *env, const char *msg) 122 { 123 JNU_ThrowByName(env, JNU_JAVAIOPKG "IOException", msg); 124 } 125 126 JNIEXPORT void JNICALL 127 JNU_ThrowNoSuchFieldError(JNIEnv *env, const char *msg) 128 { 129 JNU_ThrowByName(env, JNU_JAVAPKG "NoSuchFieldError", msg); 130 } 131 132 JNIEXPORT void JNICALL 133 JNU_ThrowNoSuchMethodError(JNIEnv *env, const char *msg) 134 { 135 JNU_ThrowByName(env, JNU_JAVAPKG "NoSuchMethodError", msg); 136 } 137 138 JNIEXPORT void JNICALL 139 JNU_ThrowStringIndexOutOfBoundsException(JNIEnv *env, const char *msg) 140 { 141 JNU_ThrowByName(env, JNU_JAVAPKG "StringIndexOutOfBoundsException", msg); 142 } 143 144 JNIEXPORT void JNICALL 145 JNU_ThrowInstantiationException(JNIEnv *env, const char *msg) 146 { 147 JNU_ThrowByName(env, JNU_JAVAPKG "InstantiationException", msg); 148 } 149 150 /* 151 * Throw an exception by name, using the string returned by 152 * getLastErrorString for the detail string. If the last-error 153 * string is NULL, use the given default detail string. 154 */ 155 JNIEXPORT void JNICALL 156 JNU_ThrowByNameWithLastError(JNIEnv *env, const char *name, 157 const char *defaultDetail) 158 { 159 char buf[255 + 1]; // 256 characters, including terminating 0 160 size_t n = getLastErrorString(buf, sizeof(buf)); 161 162 if (n > 0) { 163 JNU_ThrowByName(env, name, buf); 164 } else { 165 JNU_ThrowByName(env, name, defaultDetail); 166 } 167 } 168 169 /* 170 * Throw an exception by name, using a given message and the string 171 * returned by getLastErrorString to construct the detail string. 172 */ 173 JNIEXPORT void JNICALL 174 JNU_ThrowByNameWithMessageAndLastError 175 (JNIEnv *env, const char *name, const char *message) 176 { 177 char buf[254 + 2 + 255 + 1]; // 512 characters, including terminating 0 178 char errorBuf[255 + 1]; 179 size_t errorLen = getLastErrorString(errorBuf, sizeof(errorBuf)); 180 181 if (message != NULL && strlen(message) != 0) { 182 if (errorLen != 0) { 183 jio_snprintf(buf, sizeof(buf), "%.254s: %.255s", message, errorBuf); 184 } else { 185 jio_snprintf(buf, sizeof(buf), "%s", message); 186 } 187 } else if (errorLen != 0) { 188 jio_snprintf(buf, sizeof(buf), "%s", errorBuf); 189 } else { 190 jio_snprintf(buf, sizeof(buf), "no further information"); 191 } 192 193 JNU_ThrowByName(env, name, buf); 194 } 195 196 /* 197 * Convenience method. 198 * Call JNU_ThrowByNameWithLastError for java.io.IOException. 199 */ 200 JNIEXPORT void JNICALL 201 JNU_ThrowIOExceptionWithLastError(JNIEnv *env, const char *defaultDetail) 202 { 203 JNU_ThrowByNameWithLastError(env, JNU_JAVAIOPKG "IOException", defaultDetail); 204 } 205 206 207 JNIEXPORT jvalue JNICALL 208 JNU_CallStaticMethodByName(JNIEnv *env, 209 jboolean *hasException, 210 const char *class_name, 211 const char *name, 212 const char *signature, 213 ...) 214 { 215 jclass clazz; 216 jmethodID mid; 217 va_list args; 218 jvalue result; 219 const char *p = signature; 220 221 /* find out the return type */ 222 while (*p && *p != ')') 223 p++; 224 p++; 225 226 result.i = 0; 227 228 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 229 goto done2; 230 231 clazz = (*env)->FindClass(env, class_name); 232 if (clazz == 0) 233 goto done2; 234 mid = (*env)->GetStaticMethodID(env, clazz, name, signature); 235 if (mid == 0) 236 goto done1; 237 va_start(args, signature); 238 switch (*p) { 239 case 'V': 240 (*env)->CallStaticVoidMethodV(env, clazz, mid, args); 241 break; 242 case '[': 243 case 'L': 244 result.l = (*env)->CallStaticObjectMethodV(env, clazz, mid, args); 245 break; 246 case 'Z': 247 result.z = (*env)->CallStaticBooleanMethodV(env, clazz, mid, args); 248 break; 249 case 'B': 250 result.b = (*env)->CallStaticByteMethodV(env, clazz, mid, args); 251 break; 252 case 'C': 253 result.c = (*env)->CallStaticCharMethodV(env, clazz, mid, args); 254 break; 255 case 'S': 256 result.s = (*env)->CallStaticShortMethodV(env, clazz, mid, args); 257 break; 258 case 'I': 259 result.i = (*env)->CallStaticIntMethodV(env, clazz, mid, args); 260 break; 261 case 'J': 262 result.j = (*env)->CallStaticLongMethodV(env, clazz, mid, args); 263 break; 264 case 'F': 265 result.f = (*env)->CallStaticFloatMethodV(env, clazz, mid, args); 266 break; 267 case 'D': 268 result.d = (*env)->CallStaticDoubleMethodV(env, clazz, mid, args); 269 break; 270 default: 271 (*env)->FatalError(env, "JNU_CallStaticMethodByName: illegal signature"); 272 } 273 va_end(args); 274 275 done1: 276 (*env)->DeleteLocalRef(env, clazz); 277 done2: 278 if (hasException) { 279 *hasException = (*env)->ExceptionCheck(env); 280 } 281 return result; 282 } 283 284 JNIEXPORT jvalue JNICALL 285 JNU_CallMethodByName(JNIEnv *env, 286 jboolean *hasException, 287 jobject obj, 288 const char *name, 289 const char *signature, 290 ...) 291 { 292 jvalue result; 293 va_list args; 294 295 va_start(args, signature); 296 result = JNU_CallMethodByNameV(env, hasException, obj, name, signature, 297 args); 298 va_end(args); 299 300 return result; 301 } 302 303 304 JNIEXPORT jvalue JNICALL 305 JNU_CallMethodByNameV(JNIEnv *env, 306 jboolean *hasException, 307 jobject obj, 308 const char *name, 309 const char *signature, 310 va_list args) 311 { 312 jclass clazz; 313 jmethodID mid; 314 jvalue result; 315 const char *p = signature; 316 317 /* find out the return type */ 318 while (*p && *p != ')') 319 p++; 320 p++; 321 322 result.i = 0; 323 324 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 325 goto done2; 326 327 clazz = (*env)->GetObjectClass(env, obj); 328 mid = (*env)->GetMethodID(env, clazz, name, signature); 329 if (mid == 0) 330 goto done1; 331 332 switch (*p) { 333 case 'V': 334 (*env)->CallVoidMethodV(env, obj, mid, args); 335 break; 336 case '[': 337 case 'L': 338 result.l = (*env)->CallObjectMethodV(env, obj, mid, args); 339 break; 340 case 'Z': 341 result.z = (*env)->CallBooleanMethodV(env, obj, mid, args); 342 break; 343 case 'B': 344 result.b = (*env)->CallByteMethodV(env, obj, mid, args); 345 break; 346 case 'C': 347 result.c = (*env)->CallCharMethodV(env, obj, mid, args); 348 break; 349 case 'S': 350 result.s = (*env)->CallShortMethodV(env, obj, mid, args); 351 break; 352 case 'I': 353 result.i = (*env)->CallIntMethodV(env, obj, mid, args); 354 break; 355 case 'J': 356 result.j = (*env)->CallLongMethodV(env, obj, mid, args); 357 break; 358 case 'F': 359 result.f = (*env)->CallFloatMethodV(env, obj, mid, args); 360 break; 361 case 'D': 362 result.d = (*env)->CallDoubleMethodV(env, obj, mid, args); 363 break; 364 default: 365 (*env)->FatalError(env, "JNU_CallMethodByNameV: illegal signature"); 366 } 367 done1: 368 (*env)->DeleteLocalRef(env, clazz); 369 done2: 370 if (hasException) { 371 *hasException = (*env)->ExceptionCheck(env); 372 } 373 return result; 374 } 375 376 JNIEXPORT jobject JNICALL 377 JNU_NewObjectByName(JNIEnv *env, const char *class_name, 378 const char *constructor_sig, ...) 379 { 380 jobject obj = NULL; 381 382 jclass cls = 0; 383 jmethodID cls_initMID; 384 va_list args; 385 386 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 387 goto done; 388 389 cls = (*env)->FindClass(env, class_name); 390 if (cls == 0) { 391 goto done; 392 } 393 cls_initMID = (*env)->GetMethodID(env, cls, 394 "<init>", constructor_sig); 395 if (cls_initMID == NULL) { 396 goto done; 397 } 398 va_start(args, constructor_sig); 399 obj = (*env)->NewObjectV(env, cls, cls_initMID, args); 400 va_end(args); 401 402 done: 403 (*env)->DeleteLocalRef(env, cls); 404 return obj; 405 } 406 407 /* Optimized for char set ISO_8559_1 */ 408 static jstring 409 newString8859_1(JNIEnv *env, const char *str) 410 { 411 int len = (int)strlen(str); 412 jchar buf[512]; 413 jchar *str1; 414 jstring result; 415 int i; 416 417 if (len > 512) { 418 str1 = (jchar *)malloc(len * sizeof(jchar)); 419 if (str1 == 0) { 420 JNU_ThrowOutOfMemoryError(env, 0); 421 return 0; 422 } 423 } else 424 str1 = buf; 425 426 for (i=0;i<len;i++) 427 str1[i] = (unsigned char)str[i]; 428 result = (*env)->NewString(env, str1, len); 429 if (str1 != buf) 430 free(str1); 431 return result; 432 } 433 434 static const char* 435 getString8859_1Chars(JNIEnv *env, jstring jstr) 436 { 437 int i; 438 char *result; 439 jint len = (*env)->GetStringLength(env, jstr); 440 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 441 if (str == 0) { 442 return 0; 443 } 444 445 result = MALLOC_MIN4(len); 446 if (result == 0) { 447 (*env)->ReleaseStringCritical(env, jstr, str); 448 JNU_ThrowOutOfMemoryError(env, 0); 449 return 0; 450 } 451 452 for (i=0; i<len; i++) { 453 jchar unicode = str[i]; 454 if (unicode <= 0x00ff) 455 result[i] = (char)unicode; 456 else 457 result[i] = '?'; 458 } 459 460 result[len] = 0; 461 (*env)->ReleaseStringCritical(env, jstr, str); 462 return result; 463 } 464 465 466 /* Optimized for char set ISO646-US (us-ascii) */ 467 static jstring 468 newString646_US(JNIEnv *env, const char *str) 469 { 470 int len = (int)strlen(str); 471 jchar buf[512]; 472 jchar *str1; 473 jstring result; 474 int i; 475 476 if (len > 512) { 477 str1 = (jchar *)malloc(len * sizeof(jchar)); 478 if (str1 == 0) { 479 JNU_ThrowOutOfMemoryError(env, 0); 480 return 0; 481 } 482 } else 483 str1 = buf; 484 485 for (i=0; i<len; i++) { 486 unsigned char c = (unsigned char)str[i]; 487 if (c <= 0x7f) 488 str1[i] = c; 489 else 490 str1[i] = '?'; 491 } 492 493 result = (*env)->NewString(env, str1, len); 494 if (str1 != buf) 495 free(str1); 496 return result; 497 } 498 499 static const char* 500 getString646_USChars(JNIEnv *env, jstring jstr) 501 { 502 int i; 503 char *result; 504 jint len = (*env)->GetStringLength(env, jstr); 505 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 506 if (str == 0) { 507 return 0; 508 } 509 510 result = MALLOC_MIN4(len); 511 if (result == 0) { 512 (*env)->ReleaseStringCritical(env, jstr, str); 513 JNU_ThrowOutOfMemoryError(env, 0); 514 return 0; 515 } 516 517 for (i=0; i<len; i++) { 518 jchar unicode = str[i]; 519 if (unicode <= 0x007f ) 520 result[i] = (char)unicode; 521 else 522 result[i] = '?'; 523 } 524 525 result[len] = 0; 526 (*env)->ReleaseStringCritical(env, jstr, str); 527 return result; 528 } 529 530 /* enumeration of c1 row from Cp1252 */ 531 static int cp1252c1chars[32] = { 532 0x20AC,0xFFFD,0x201A,0x0192,0x201E,0x2026,0x2020,0x2021, 533 0x02C6,0x2030,0x0160,0x2039,0x0152,0xFFFD,0x017D,0xFFFD, 534 0xFFFD,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014, 535 0x02Dc,0x2122,0x0161,0x203A,0x0153,0xFFFD,0x017E,0x0178 536 }; 537 538 /* Optimized for char set Cp1252 */ 539 static jstring 540 newStringCp1252(JNIEnv *env, const char *str) 541 { 542 int len = (int) strlen(str); 543 jchar buf[512]; 544 jchar *str1; 545 jstring result; 546 int i; 547 if (len > 512) { 548 str1 = (jchar *)malloc(len * sizeof(jchar)); 549 if (str1 == 0) { 550 JNU_ThrowOutOfMemoryError(env, 0); 551 return 0; 552 } 553 } else 554 str1 = buf; 555 556 for (i=0; i<len; i++) { 557 unsigned char c = (unsigned char)str[i]; 558 if ((c >= 0x80) && (c <= 0x9f)) 559 str1[i] = cp1252c1chars[c-128]; 560 else 561 str1[i] = c; 562 } 563 564 result = (*env)->NewString(env, str1, len); 565 if (str1 != buf) 566 free(str1); 567 return result; 568 } 569 570 static const char* 571 getStringCp1252Chars(JNIEnv *env, jstring jstr) 572 { 573 int i; 574 char *result; 575 jint len = (*env)->GetStringLength(env, jstr); 576 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 577 if (str == 0) { 578 return 0; 579 } 580 581 result = MALLOC_MIN4(len); 582 if (result == 0) { 583 (*env)->ReleaseStringCritical(env, jstr, str); 584 JNU_ThrowOutOfMemoryError(env, 0); 585 return 0; 586 } 587 588 for (i=0; i<len; i++) { 589 jchar c = str[i]; 590 if (c < 256) 591 result[i] = (char)c; 592 else switch(c) { 593 case 0x20AC: result[i] = (char)0x80; break; 594 case 0x201A: result[i] = (char)0x82; break; 595 case 0x0192: result[i] = (char)0x83; break; 596 case 0x201E: result[i] = (char)0x84; break; 597 case 0x2026: result[i] = (char)0x85; break; 598 case 0x2020: result[i] = (char)0x86; break; 599 case 0x2021: result[i] = (char)0x87; break; 600 case 0x02C6: result[i] = (char)0x88; break; 601 case 0x2030: result[i] = (char)0x89; break; 602 case 0x0160: result[i] = (char)0x8A; break; 603 case 0x2039: result[i] = (char)0x8B; break; 604 case 0x0152: result[i] = (char)0x8C; break; 605 case 0x017D: result[i] = (char)0x8E; break; 606 case 0x2018: result[i] = (char)0x91; break; 607 case 0x2019: result[i] = (char)0x92; break; 608 case 0x201C: result[i] = (char)0x93; break; 609 case 0x201D: result[i] = (char)0x94; break; 610 case 0x2022: result[i] = (char)0x95; break; 611 case 0x2013: result[i] = (char)0x96; break; 612 case 0x2014: result[i] = (char)0x97; break; 613 case 0x02DC: result[i] = (char)0x98; break; 614 case 0x2122: result[i] = (char)0x99; break; 615 case 0x0161: result[i] = (char)0x9A; break; 616 case 0x203A: result[i] = (char)0x9B; break; 617 case 0x0153: result[i] = (char)0x9C; break; 618 case 0x017E: result[i] = (char)0x9E; break; 619 case 0x0178: result[i] = (char)0x9F; break; 620 default: result[i] = '?'; break; 621 } 622 } 623 624 result[len] = 0; 625 (*env)->ReleaseStringCritical(env, jstr, str); 626 return result; 627 } 628 629 static int fastEncoding = NO_ENCODING_YET; 630 static jstring jnuEncoding = NULL; 631 632 /* Cached method IDs */ 633 static jmethodID String_init_ID; /* String(byte[], enc) */ 634 static jmethodID String_getBytes_ID; /* String.getBytes(enc) */ 635 636 int getFastEncoding() { 637 return fastEncoding; 638 } 639 640 /* Initialize the fast encoding. If the "sun.jnu.encoding" property 641 * has not yet been set, we leave fastEncoding == NO_ENCODING_YET. 642 */ 643 void 644 initializeEncoding(JNIEnv *env) 645 { 646 jstring propname = 0; 647 jstring enc = 0; 648 jclass strClazz = NULL; 649 650 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 651 return; 652 653 strClazz = JNU_ClassString(env); 654 CHECK_NULL(strClazz); 655 656 propname = (*env)->NewStringUTF(env, "sun.jnu.encoding"); 657 if (propname) { 658 jboolean exc; 659 enc = JNU_CallStaticMethodByName 660 (env, 661 &exc, 662 "java/lang/System", 663 "getProperty", 664 "(Ljava/lang/String;)Ljava/lang/String;", 665 propname).l; 666 if (!exc) { 667 if (enc) { 668 const char* encname = (*env)->GetStringUTFChars(env, enc, 0); 669 if (encname) { 670 /* 671 * On Solaris with nl_langinfo() called in GetJavaProperties(): 672 * 673 * locale undefined -> NULL -> hardcoded default 674 * "C" locale -> "" -> hardcoded default (on 2.6) 675 * "C" locale -> "ISO646-US" (on Sol 7/8) 676 * "en_US" locale -> "ISO8859-1" 677 * "en_GB" locale -> "ISO8859-1" (on Sol 7/8) 678 * "en_UK" locale -> "ISO8859-1" (on 2.6) 679 */ 680 if ((strcmp(encname, "8859_1") == 0) || 681 (strcmp(encname, "ISO8859-1") == 0) || 682 (strcmp(encname, "ISO8859_1") == 0) || 683 (strcmp(encname, "ISO-8859-1") == 0)) 684 fastEncoding = FAST_8859_1; 685 else if (strcmp(encname, "ISO646-US") == 0) 686 fastEncoding = FAST_646_US; 687 else if (strcmp(encname, "Cp1252") == 0 || 688 /* This is a temporary fix until we move */ 689 /* to wide character versions of all Windows */ 690 /* calls. */ 691 strcmp(encname, "utf-16le") == 0) 692 fastEncoding = FAST_CP1252; 693 else { 694 fastEncoding = NO_FAST_ENCODING; 695 jnuEncoding = (jstring)(*env)->NewGlobalRef(env, enc); 696 } 697 (*env)->ReleaseStringUTFChars(env, enc, encname); 698 } 699 } 700 } else { 701 (*env)->ExceptionClear(env); 702 } 703 } else { 704 (*env)->ExceptionClear(env); 705 } 706 (*env)->DeleteLocalRef(env, propname); 707 (*env)->DeleteLocalRef(env, enc); 708 709 /* Initialize method-id cache */ 710 String_getBytes_ID = (*env)->GetMethodID(env, strClazz, 711 "getBytes", "(Ljava/lang/String;)[B"); 712 CHECK_NULL(String_getBytes_ID); 713 String_init_ID = (*env)->GetMethodID(env, strClazz, 714 "<init>", "([BLjava/lang/String;)V"); 715 } 716 717 static jboolean isJNUEncodingSupported = JNI_FALSE; 718 static jboolean jnuEncodingSupported(JNIEnv *env) { 719 jboolean exe; 720 if (isJNUEncodingSupported == JNI_TRUE) { 721 return JNI_TRUE; 722 } 723 isJNUEncodingSupported = (jboolean) JNU_CallStaticMethodByName ( 724 env, &exe, 725 "java/nio/charset/Charset", 726 "isSupported", 727 "(Ljava/lang/String;)Z", 728 jnuEncoding).z; 729 return isJNUEncodingSupported; 730 } 731 732 733 JNIEXPORT jstring 734 NewStringPlatform(JNIEnv *env, const char *str) 735 { 736 return JNU_NewStringPlatform(env, str); 737 } 738 739 JNIEXPORT jstring JNICALL 740 JNU_NewStringPlatform(JNIEnv *env, const char *str) 741 { 742 jstring result = NULL; 743 jbyteArray hab = 0; 744 int len; 745 746 if (fastEncoding == NO_ENCODING_YET) { 747 initializeEncoding(env); 748 JNU_CHECK_EXCEPTION_RETURN(env, NULL); 749 } 750 751 if ((fastEncoding == FAST_8859_1) || (fastEncoding == NO_ENCODING_YET)) 752 return newString8859_1(env, str); 753 if (fastEncoding == FAST_646_US) 754 return newString646_US(env, str); 755 if (fastEncoding == FAST_CP1252) 756 return newStringCp1252(env, str); 757 758 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 759 return NULL; 760 761 len = (int)strlen(str); 762 hab = (*env)->NewByteArray(env, len); 763 if (hab != 0) { 764 jclass strClazz = JNU_ClassString(env); 765 CHECK_NULL_RETURN(strClazz, 0); 766 (*env)->SetByteArrayRegion(env, hab, 0, len, (jbyte *)str); 767 if (jnuEncodingSupported(env)) { 768 result = (*env)->NewObject(env, strClazz, 769 String_init_ID, hab, jnuEncoding); 770 } else { 771 /*If the encoding specified in sun.jnu.encoding is not endorsed 772 by "Charset.isSupported" we have to fall back to use String(byte[]) 773 explicitly here without specifying the encoding name, in which the 774 StringCoding class will pickup the iso-8859-1 as the fallback 775 converter for us. 776 */ 777 jmethodID mid = (*env)->GetMethodID(env, strClazz, 778 "<init>", "([B)V"); 779 if (mid != NULL) { 780 result = (*env)->NewObject(env, strClazz, mid, hab); 781 } 782 } 783 (*env)->DeleteLocalRef(env, hab); 784 return result; 785 } 786 return NULL; 787 } 788 789 JNIEXPORT const char * 790 GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy) 791 { 792 return JNU_GetStringPlatformChars(env, jstr, isCopy); 793 } 794 795 JNIEXPORT const char * JNICALL 796 JNU_GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy) 797 { 798 char *result = NULL; 799 jbyteArray hab = 0; 800 801 if (isCopy) 802 *isCopy = JNI_TRUE; 803 804 if (fastEncoding == NO_ENCODING_YET) { 805 initializeEncoding(env); 806 JNU_CHECK_EXCEPTION_RETURN(env, 0); 807 } 808 809 if ((fastEncoding == FAST_8859_1) || (fastEncoding == NO_ENCODING_YET)) 810 return getString8859_1Chars(env, jstr); 811 if (fastEncoding == FAST_646_US) 812 return getString646_USChars(env, jstr); 813 if (fastEncoding == FAST_CP1252) 814 return getStringCp1252Chars(env, jstr); 815 816 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 817 return 0; 818 819 if (jnuEncodingSupported(env)) { 820 hab = (*env)->CallObjectMethod(env, jstr, String_getBytes_ID, jnuEncoding); 821 } else { 822 jmethodID mid; 823 jclass strClazz = JNU_ClassString(env); 824 CHECK_NULL_RETURN(strClazz, 0); 825 mid = (*env)->GetMethodID(env, strClazz, 826 "getBytes", "()[B"); 827 if (mid != NULL) { 828 hab = (*env)->CallObjectMethod(env, jstr, mid); 829 } 830 } 831 832 if (!(*env)->ExceptionCheck(env)) { 833 jint len = (*env)->GetArrayLength(env, hab); 834 result = MALLOC_MIN4(len); 835 if (result == 0) { 836 JNU_ThrowOutOfMemoryError(env, 0); 837 (*env)->DeleteLocalRef(env, hab); 838 return 0; 839 } 840 (*env)->GetByteArrayRegion(env, hab, 0, len, (jbyte *)result); 841 result[len] = 0; /* NULL-terminate */ 842 } 843 844 (*env)->DeleteLocalRef(env, hab); 845 return result; 846 } 847 848 JNIEXPORT void JNICALL 849 JNU_ReleaseStringPlatformChars(JNIEnv *env, jstring jstr, const char *str) 850 { 851 free((void *)str); 852 } 853 854 /* 855 * Export the platform dependent path canonicalization so that 856 * VM can find it when loading system classes. 857 * This function is also used by the instrumentation agent. 858 */ 859 extern int canonicalize(char *path, const char *out, int len); 860 861 JNIEXPORT int 862 Canonicalize(JNIEnv *unused, char *orig, char *out, int len) 863 { 864 /* canonicalize an already natived path */ 865 return canonicalize(orig, out, len); 866 } 867 868 JNIEXPORT jclass JNICALL 869 JNU_ClassString(JNIEnv *env) 870 { 871 static jclass cls = 0; 872 if (cls == 0) { 873 jclass c; 874 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 875 return 0; 876 c = (*env)->FindClass(env, "java/lang/String"); 877 CHECK_NULL_RETURN(c, NULL); 878 cls = (*env)->NewGlobalRef(env, c); 879 (*env)->DeleteLocalRef(env, c); 880 } 881 return cls; 882 } 883 884 JNIEXPORT jclass JNICALL 885 JNU_ClassClass(JNIEnv *env) 886 { 887 static jclass cls = 0; 888 if (cls == 0) { 889 jclass c; 890 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 891 return 0; 892 c = (*env)->FindClass(env, "java/lang/Class"); 893 CHECK_NULL_RETURN(c, NULL); 894 cls = (*env)->NewGlobalRef(env, c); 895 (*env)->DeleteLocalRef(env, c); 896 } 897 return cls; 898 } 899 900 JNIEXPORT jclass JNICALL 901 JNU_ClassObject(JNIEnv *env) 902 { 903 static jclass cls = 0; 904 if (cls == 0) { 905 jclass c; 906 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 907 return 0; 908 c = (*env)->FindClass(env, "java/lang/Object"); 909 CHECK_NULL_RETURN(c, NULL); 910 cls = (*env)->NewGlobalRef(env, c); 911 (*env)->DeleteLocalRef(env, c); 912 } 913 return cls; 914 } 915 916 JNIEXPORT jclass JNICALL 917 JNU_ClassThrowable(JNIEnv *env) 918 { 919 static jclass cls = 0; 920 if (cls == 0) { 921 jclass c; 922 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 923 return 0; 924 c = (*env)->FindClass(env, "java/lang/Throwable"); 925 CHECK_NULL_RETURN(c, NULL); 926 cls = (*env)->NewGlobalRef(env, c); 927 (*env)->DeleteLocalRef(env, c); 928 } 929 return cls; 930 } 931 932 JNIEXPORT jint JNICALL 933 JNU_CopyObjectArray(JNIEnv *env, jobjectArray dst, jobjectArray src, 934 jint count) 935 { 936 int i; 937 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 938 return -1; 939 for (i=0; i<count; i++) { 940 jstring p = (*env)->GetObjectArrayElement(env, src, i); 941 (*env)->SetObjectArrayElement(env, dst, i, p); 942 (*env)->DeleteLocalRef(env, p); 943 } 944 return 0; 945 } 946 947 JNIEXPORT void * JNICALL 948 JNU_GetEnv(JavaVM *vm, jint version) 949 { 950 void *env; 951 (*vm)->GetEnv(vm, &env, version); 952 return env; 953 } 954 955 JNIEXPORT jint JNICALL 956 JNU_IsInstanceOfByName(JNIEnv *env, jobject object, char* classname) 957 { 958 jclass cls; 959 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 960 return JNI_ERR; 961 cls = (*env)->FindClass(env, classname); 962 if (cls != NULL) { 963 jint result = (*env)->IsInstanceOf(env, object, cls); 964 (*env)->DeleteLocalRef(env, cls); 965 return result; 966 } 967 return JNI_ERR; 968 } 969 970 JNIEXPORT jboolean JNICALL 971 JNU_Equals(JNIEnv *env, jobject object1, jobject object2) 972 { 973 static jmethodID mid = NULL; 974 if (mid == NULL) { 975 jclass objClazz = JNU_ClassObject(env); 976 CHECK_NULL_RETURN(objClazz, JNI_FALSE); 977 mid = (*env)->GetMethodID(env, objClazz, "equals", 978 "(Ljava/lang/Object;)Z"); 979 CHECK_NULL_RETURN(mid, JNI_FALSE); 980 } 981 return (*env)->CallBooleanMethod(env, object1, mid, object2); 982 } 983 984 985 /************************************************************************ 986 * Thread calls 987 */ 988 989 static jmethodID Object_waitMID; 990 static jmethodID Object_notifyMID; 991 static jmethodID Object_notifyAllMID; 992 993 JNIEXPORT void JNICALL 994 JNU_MonitorWait(JNIEnv *env, jobject object, jlong timeout) 995 { 996 if (object == NULL) { 997 JNU_ThrowNullPointerException(env, "JNU_MonitorWait argument"); 998 return; 999 } 1000 if (Object_waitMID == NULL) { 1001 jclass cls = JNU_ClassObject(env); 1002 if (cls == NULL) { 1003 return; 1004 } 1005 Object_waitMID = (*env)->GetMethodID(env, cls, "wait", "(J)V"); 1006 if (Object_waitMID == NULL) { 1007 return; 1008 } 1009 } 1010 (*env)->CallVoidMethod(env, object, Object_waitMID, timeout); 1011 } 1012 1013 JNIEXPORT void JNICALL 1014 JNU_Notify(JNIEnv *env, jobject object) 1015 { 1016 if (object == NULL) { 1017 JNU_ThrowNullPointerException(env, "JNU_Notify argument"); 1018 return; 1019 } 1020 if (Object_notifyMID == NULL) { 1021 jclass cls = JNU_ClassObject(env); 1022 if (cls == NULL) { 1023 return; 1024 } 1025 Object_notifyMID = (*env)->GetMethodID(env, cls, "notify", "()V"); 1026 if (Object_notifyMID == NULL) { 1027 return; 1028 } 1029 } 1030 (*env)->CallVoidMethod(env, object, Object_notifyMID); 1031 } 1032 1033 JNIEXPORT void JNICALL 1034 JNU_NotifyAll(JNIEnv *env, jobject object) 1035 { 1036 if (object == NULL) { 1037 JNU_ThrowNullPointerException(env, "JNU_NotifyAll argument"); 1038 return; 1039 } 1040 if (Object_notifyAllMID == NULL) { 1041 jclass cls = JNU_ClassObject(env); 1042 if (cls == NULL) { 1043 return; 1044 } 1045 Object_notifyAllMID = (*env)->GetMethodID(env, cls,"notifyAll", "()V"); 1046 if (Object_notifyAllMID == NULL) { 1047 return; 1048 } 1049 } 1050 (*env)->CallVoidMethod(env, object, Object_notifyAllMID); 1051 } 1052 1053 1054 /************************************************************************ 1055 * Debugging utilities 1056 */ 1057 1058 JNIEXPORT void JNICALL 1059 JNU_PrintString(JNIEnv *env, char *hdr, jstring string) 1060 { 1061 if (string == NULL) { 1062 fprintf(stderr, "%s: is NULL\n", hdr); 1063 } else { 1064 const char *stringPtr = JNU_GetStringPlatformChars(env, string, 0); 1065 if (stringPtr == 0) 1066 return; 1067 fprintf(stderr, "%s: %s\n", hdr, stringPtr); 1068 JNU_ReleaseStringPlatformChars(env, string, stringPtr); 1069 } 1070 } 1071 1072 JNIEXPORT void JNICALL 1073 JNU_PrintClass(JNIEnv *env, char* hdr, jobject object) 1074 { 1075 if (object == NULL) { 1076 fprintf(stderr, "%s: object is NULL\n", hdr); 1077 return; 1078 } else { 1079 jclass cls = (*env)->GetObjectClass(env, object); 1080 jstring clsName = JNU_ToString(env, cls); 1081 if (clsName == NULL) { 1082 JNU_PrintString(env, hdr, clsName); 1083 } 1084 (*env)->DeleteLocalRef(env, cls); 1085 (*env)->DeleteLocalRef(env, clsName); 1086 } 1087 } 1088 1089 JNIEXPORT jstring JNICALL 1090 JNU_ToString(JNIEnv *env, jobject object) 1091 { 1092 if (object == NULL) { 1093 return (*env)->NewStringUTF(env, "NULL"); 1094 } else { 1095 return (jstring)JNU_CallMethodByName(env, 1096 NULL, 1097 object, 1098 "toString", 1099 "()Ljava/lang/String;").l; 1100 } 1101 } 1102 1103 JNIEXPORT jvalue JNICALL 1104 JNU_GetFieldByName(JNIEnv *env, 1105 jboolean *hasException, 1106 jobject obj, 1107 const char *name, 1108 const char *signature) 1109 { 1110 jclass cls; 1111 jfieldID fid; 1112 jvalue result; 1113 1114 result.i = 0; 1115 1116 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1117 goto done2; 1118 1119 cls = (*env)->GetObjectClass(env, obj); 1120 fid = (*env)->GetFieldID(env, cls, name, signature); 1121 if (fid == 0) 1122 goto done1; 1123 1124 switch (*signature) { 1125 case '[': 1126 case 'L': 1127 result.l = (*env)->GetObjectField(env, obj, fid); 1128 break; 1129 case 'Z': 1130 result.z = (*env)->GetBooleanField(env, obj, fid); 1131 break; 1132 case 'B': 1133 result.b = (*env)->GetByteField(env, obj, fid); 1134 break; 1135 case 'C': 1136 result.c = (*env)->GetCharField(env, obj, fid); 1137 break; 1138 case 'S': 1139 result.s = (*env)->GetShortField(env, obj, fid); 1140 break; 1141 case 'I': 1142 result.i = (*env)->GetIntField(env, obj, fid); 1143 break; 1144 case 'J': 1145 result.j = (*env)->GetLongField(env, obj, fid); 1146 break; 1147 case 'F': 1148 result.f = (*env)->GetFloatField(env, obj, fid); 1149 break; 1150 case 'D': 1151 result.d = (*env)->GetDoubleField(env, obj, fid); 1152 break; 1153 1154 default: 1155 (*env)->FatalError(env, "JNU_GetFieldByName: illegal signature"); 1156 } 1157 1158 done1: 1159 (*env)->DeleteLocalRef(env, cls); 1160 done2: 1161 if (hasException) { 1162 *hasException = (*env)->ExceptionCheck(env); 1163 } 1164 return result; 1165 } 1166 1167 JNIEXPORT void JNICALL 1168 JNU_SetFieldByName(JNIEnv *env, 1169 jboolean *hasException, 1170 jobject obj, 1171 const char *name, 1172 const char *signature, 1173 ...) 1174 { 1175 jclass cls; 1176 jfieldID fid; 1177 va_list args; 1178 1179 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1180 goto done2; 1181 1182 cls = (*env)->GetObjectClass(env, obj); 1183 fid = (*env)->GetFieldID(env, cls, name, signature); 1184 if (fid == 0) 1185 goto done1; 1186 1187 va_start(args, signature); 1188 switch (*signature) { 1189 case '[': 1190 case 'L': 1191 (*env)->SetObjectField(env, obj, fid, va_arg(args, jobject)); 1192 break; 1193 case 'Z': 1194 (*env)->SetBooleanField(env, obj, fid, (jboolean)va_arg(args, int)); 1195 break; 1196 case 'B': 1197 (*env)->SetByteField(env, obj, fid, (jbyte)va_arg(args, int)); 1198 break; 1199 case 'C': 1200 (*env)->SetCharField(env, obj, fid, (jchar)va_arg(args, int)); 1201 break; 1202 case 'S': 1203 (*env)->SetShortField(env, obj, fid, (jshort)va_arg(args, int)); 1204 break; 1205 case 'I': 1206 (*env)->SetIntField(env, obj, fid, va_arg(args, jint)); 1207 break; 1208 case 'J': 1209 (*env)->SetLongField(env, obj, fid, va_arg(args, jlong)); 1210 break; 1211 case 'F': 1212 (*env)->SetFloatField(env, obj, fid, (jfloat)va_arg(args, jdouble)); 1213 break; 1214 case 'D': 1215 (*env)->SetDoubleField(env, obj, fid, va_arg(args, jdouble)); 1216 break; 1217 1218 default: 1219 (*env)->FatalError(env, "JNU_SetFieldByName: illegal signature"); 1220 } 1221 va_end(args); 1222 1223 done1: 1224 (*env)->DeleteLocalRef(env, cls); 1225 done2: 1226 if (hasException) { 1227 *hasException = (*env)->ExceptionCheck(env); 1228 } 1229 } 1230 1231 JNIEXPORT jvalue JNICALL 1232 JNU_GetStaticFieldByName(JNIEnv *env, 1233 jboolean *hasException, 1234 const char *classname, 1235 const char *name, 1236 const char *signature) 1237 { 1238 jclass cls; 1239 jfieldID fid; 1240 jvalue result; 1241 1242 result.i = 0; 1243 1244 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1245 goto done2; 1246 1247 cls = (*env)->FindClass(env, classname); 1248 if (cls == 0) 1249 goto done2; 1250 1251 fid = (*env)->GetStaticFieldID(env, cls, name, signature); 1252 if (fid == 0) 1253 goto done1; 1254 1255 switch (*signature) { 1256 case '[': 1257 case 'L': 1258 result.l = (*env)->GetStaticObjectField(env, cls, fid); 1259 break; 1260 case 'Z': 1261 result.z = (*env)->GetStaticBooleanField(env, cls, fid); 1262 break; 1263 case 'B': 1264 result.b = (*env)->GetStaticByteField(env, cls, fid); 1265 break; 1266 case 'C': 1267 result.c = (*env)->GetStaticCharField(env, cls, fid); 1268 break; 1269 case 'S': 1270 result.s = (*env)->GetStaticShortField(env, cls, fid); 1271 break; 1272 case 'I': 1273 result.i = (*env)->GetStaticIntField(env, cls, fid); 1274 break; 1275 case 'J': 1276 result.j = (*env)->GetStaticLongField(env, cls, fid); 1277 break; 1278 case 'F': 1279 result.f = (*env)->GetStaticFloatField(env, cls, fid); 1280 break; 1281 case 'D': 1282 result.d = (*env)->GetStaticDoubleField(env, cls, fid); 1283 break; 1284 1285 default: 1286 (*env)->FatalError(env, "JNU_GetStaticFieldByName: illegal signature"); 1287 } 1288 1289 done1: 1290 (*env)->DeleteLocalRef(env, cls); 1291 done2: 1292 if (hasException) { 1293 *hasException = (*env)->ExceptionCheck(env); 1294 } 1295 return result; 1296 } 1297 1298 JNIEXPORT void JNICALL 1299 JNU_SetStaticFieldByName(JNIEnv *env, 1300 jboolean *hasException, 1301 const char *classname, 1302 const char *name, 1303 const char *signature, 1304 ...) 1305 { 1306 jclass cls; 1307 jfieldID fid; 1308 va_list args; 1309 1310 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1311 goto done2; 1312 1313 cls = (*env)->FindClass(env, classname); 1314 if (cls == 0) 1315 goto done2; 1316 1317 fid = (*env)->GetStaticFieldID(env, cls, name, signature); 1318 if (fid == 0) 1319 goto done1; 1320 1321 va_start(args, signature); 1322 switch (*signature) { 1323 case '[': 1324 case 'L': 1325 (*env)->SetStaticObjectField(env, cls, fid, va_arg(args, jobject)); 1326 break; 1327 case 'Z': 1328 (*env)->SetStaticBooleanField(env, cls, fid, (jboolean)va_arg(args, int)); 1329 break; 1330 case 'B': 1331 (*env)->SetStaticByteField(env, cls, fid, (jbyte)va_arg(args, int)); 1332 break; 1333 case 'C': 1334 (*env)->SetStaticCharField(env, cls, fid, (jchar)va_arg(args, int)); 1335 break; 1336 case 'S': 1337 (*env)->SetStaticShortField(env, cls, fid, (jshort)va_arg(args, int)); 1338 break; 1339 case 'I': 1340 (*env)->SetStaticIntField(env, cls, fid, va_arg(args, jint)); 1341 break; 1342 case 'J': 1343 (*env)->SetStaticLongField(env, cls, fid, va_arg(args, jlong)); 1344 break; 1345 case 'F': 1346 (*env)->SetStaticFloatField(env, cls, fid, (jfloat)va_arg(args, jdouble)); 1347 break; 1348 case 'D': 1349 (*env)->SetStaticDoubleField(env, cls, fid, va_arg(args, jdouble)); 1350 break; 1351 1352 default: 1353 (*env)->FatalError(env, "JNU_SetStaticFieldByName: illegal signature"); 1354 } 1355 va_end(args); 1356 1357 done1: 1358 (*env)->DeleteLocalRef(env, cls); 1359 done2: 1360 if (hasException) { 1361 *hasException = (*env)->ExceptionCheck(env); 1362 } 1363 }