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