/*

 * 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.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_jniCheck.cpp.incl"

// Heap objects are allowed to be directly referenced only in VM code,

// not in native code.

#define ASSERT_OOPS_ALLOWED                                          \

    assert(JavaThread::current()->thread_state() == _thread_in_vm,   \

           "jniCheck examining oops in bad state.")

// Execute the given block of source code with the thread in VM state.

// To do this, transition from the NATIVE state to the VM state, execute

// the code, and transtition back.  The ThreadInVMfromNative constructor

// performs the transition to VM state, its destructor restores the

// NATIVE state.

#define IN_VM(source_code)   {                                         \

    {                                                                  \

      ThreadInVMfromNative __tiv(thr);                                 \

      source_code                                                      \

    }                                                                  \

  }

/*

 * DECLARATIONS

 */

static struct JNINativeInterface_ * unchecked_jni_NativeInterface;

/*

 * MACRO DEFINITIONS

 */

// All JNI checked functions here use JNI_ENTRY_CHECKED() instead of the

// QUICK_ENTRY or LEAF variants found in jni.cpp.  This allows handles

// to be created if a fatal error should occur.

// Check for thread not attached to VM;  need to catch this before

// assertions in the wrapper routines might fire

// Check for env being the one value appropriate for this thread.

#define JNI_ENTRY_CHECKED(result_type, header)                           \

extern "C" {                                                             \

  result_type JNICALL header {                                           \

    JavaThread* thr = (JavaThread*)ThreadLocalStorage::get_thread_slow();\

    if (thr == NULL || !thr->is_Java_thread()) {                         \

      tty->print_cr(fatal_using_jnienv_in_nonjava);                      \

      os::abort(true);                                                   \

    }                                                                    \

    JNIEnv* xenv = thr->jni_environment();                               \

    if (env != xenv) {                                                   \

      NativeReportJNIFatalError(thr, warn_wrong_jnienv);                 \

    }                                                                    \

    __ENTRY(result_type, header, thr)

#define UNCHECKED() (unchecked_jni_NativeInterface)

static const char * warn_wrong_jnienv = "Using JNIEnv in the wrong thread";

static const char * warn_bad_class_descriptor = "JNI FindClass received a bad class descriptor \"%s\".  A correct class descriptor " \

  "has no leading \"L\" or trailing \";\".  Incorrect descriptors will not be accepted in future releases.";

static const char * fatal_using_jnienv_in_nonjava = "FATAL ERROR in native method: Using JNIEnv in non-Java thread";

static const char * warn_other_function_in_critical = "Warning: Calling other JNI functions in the scope of " \

  "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical";

static const char * fatal_bad_ref_to_jni = "Bad global or local ref passed to JNI";

static const char * fatal_received_null_class = "JNI received a null class";

static const char * fatal_class_not_a_class = "JNI received a class argument that is not a class";

static const char * fatal_class_not_a_throwable_class = "JNI Throw or ThrowNew received a class argument that is not a Throwable or Throwable subclass";

static const char * fatal_wrong_class_or_method = "Wrong object class or methodID passed to JNI call";

static const char * fatal_unknown_array_object = "Unknown array object passed to JNI array operations";

static const char * fatal_object_array_expected = "Object array expected but not received for JNI array operation";

static const char * fatal_non_array  = "Non-array passed to JNI array operations";

static const char * fatal_element_type_mismatch = "Array element type mismatch in JNI";

static const char * fatal_should_be_static = "Non-static field ID passed to JNI";

static const char * fatal_wrong_static_field = "Wrong static field ID passed to JNI";

static const char * fatal_static_field_not_found = "Static field not found in JNI get/set field operations";

static const char * fatal_static_field_mismatch = "Field type (static) mismatch in JNI get/set field operations";

static const char * fatal_should_be_nonstatic = "Static field ID passed to JNI";

static const char * fatal_null_object = "Null object passed to JNI";

static const char * fatal_wrong_field = "Wrong field ID passed to JNI";

static const char * fatal_instance_field_not_found = "Instance field not found in JNI get/set field operations";

static const char * fatal_instance_field_mismatch = "Field type (instance) mismatch in JNI get/set field operations";

static const char * fatal_non_string = "JNI string operation received a non-string";

// When in VM state:

static void ReportJNIWarning(JavaThread* thr, const char *msg) {

  tty->print_cr("WARNING in native method: %s", msg);

  thr->print_stack();

}

// When in NATIVE state:

static void NativeReportJNIFatalError(JavaThread* thr, const char *msg) {

  IN_VM(

    ReportJNIFatalError(thr, msg);

  )

}

static void NativeReportJNIWarning(JavaThread* thr, const char *msg) {

  IN_VM(

    ReportJNIWarning(thr, msg);

  )

}

/*

 * SUPPORT FUNCTIONS

 */

static inline void

functionEnterCritical(JavaThread* thr)

{

  if (thr->has_pending_exception()) {

    NativeReportJNIWarning(thr, "JNI call made with exception pending");

  }

}

static inline void

functionEnterCriticalExceptionAllowed(JavaThread* thr)

{

}

static inline void

functionEnter(JavaThread* thr)

{

  if (thr->in_critical()) {

    tty->print_cr(warn_other_function_in_critical);

  }

  if (thr->has_pending_exception()) {

    NativeReportJNIWarning(thr, "JNI call made with exception pending");

  }

}

static inline void

functionEnterExceptionAllowed(JavaThread* thr)

{

  if (thr->in_critical()) {

    tty->print_cr(warn_other_function_in_critical);

  }

}

static inline void

functionExit(JNIEnv *env)

{

  /* nothing to do at this time */

}

static inline void

checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)

{

  fieldDescriptor fd;

  /* make sure it is a static field */

  if (!jfieldIDWorkaround::is_static_jfieldID(fid))

    ReportJNIFatalError(thr, fatal_should_be_static);

  /* validate the class being passed */

  ASSERT_OOPS_ALLOWED;

  klassOop k_oop = jniCheck::validate_class(thr, cls, false);

  /* check for proper subclass hierarchy */

  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);

  klassOop f_oop = id->holder();

  if (!instanceKlass::cast(k_oop)->is_subtype_of(f_oop))

    ReportJNIFatalError(thr, fatal_wrong_static_field);

  /* check for proper field type */

  if (!instanceKlass::cast(f_oop)->find_local_field_from_offset(

          id->offset(), true, &fd))

    ReportJNIFatalError(thr, fatal_static_field_not_found);

  if ((fd.field_type() != ftype) &&

      !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {

    ReportJNIFatalError(thr, fatal_static_field_mismatch);

  }

}

static inline void

checkInstanceFieldID(JavaThread* thr, jfieldID fid, jobject obj, int ftype)

{

  fieldDescriptor fd;

  /* make sure it is an instance field */

  if (jfieldIDWorkaround::is_static_jfieldID(fid))

    ReportJNIFatalError(thr, fatal_should_be_nonstatic);

  /* validate the object being passed and then get its class */

  ASSERT_OOPS_ALLOWED;

  oop oopObj = jniCheck::validate_object(thr, obj);

  if (!oopObj) {

    ReportJNIFatalError(thr, fatal_null_object);

  }

  klassOop k_oop = oopObj->klass();

  if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) {

    ReportJNIFatalError(thr, fatal_wrong_field);

  }

  /* make sure the field exists */

  int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid);

  if (!instanceKlass::cast(k_oop)->contains_field_offset(offset))

    ReportJNIFatalError(thr, fatal_wrong_field);

  /* check for proper field type */

  if (!instanceKlass::cast(k_oop)->find_field_from_offset(offset,

                                                              false, &fd))

    ReportJNIFatalError(thr, fatal_instance_field_not_found);

  if ((fd.field_type() != ftype) &&

      !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {

    ReportJNIFatalError(thr, fatal_instance_field_mismatch);

  }

}

static inline void

checkString(JavaThread* thr, jstring js)

{

  ASSERT_OOPS_ALLOWED;

  oop s = jniCheck::validate_object(thr, js);

  if (!s || !java_lang_String::is_instance(s))

    ReportJNIFatalError(thr, fatal_non_string);

}

static inline void

checkArray(JavaThread* thr, jarray jArray, int elementType)

{

  ASSERT_OOPS_ALLOWED;

  arrayOop aOop;

  aOop = (arrayOop)jniCheck::validate_object(thr, jArray);

  if (aOop == NULL || !aOop->is_array())

    ReportJNIFatalError(thr, fatal_non_array);

  if (elementType != -1) {

    if (aOop->is_typeArray()) {

      BasicType array_type = typeArrayKlass::cast(aOop->klass())->element_type();

      if (array_type != elementType)

        ReportJNIFatalError(thr, fatal_element_type_mismatch);

      } else if (aOop->is_objArray()) {

        if ( T_OBJECT != elementType)

          ReportJNIFatalError(thr, fatal_object_array_expected);

      } else {

        ReportJNIFatalError(thr, fatal_unknown_array_object);

    }

  }

}

oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {

  if (JNIHandles::is_frame_handle(thr, obj) ||

      JNIHandles::is_local_handle(thr, obj) ||

      JNIHandles::is_global_handle(obj) ||

      JNIHandles::is_weak_global_handle(obj)) {

    ASSERT_OOPS_ALLOWED;

    return JNIHandles::resolve_external_guard(obj);

  }

  ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

  return NULL;

}

methodOop jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {

  ASSERT_OOPS_ALLOWED;

  methodOop moop = JNIHandles::checked_resolve_jmethod_id(method_id);

  if (moop == NULL) {

    ReportJNIFatalError(thr, fatal_wrong_class_or_method);

  }

  return moop;

}

oop jniCheck::validate_object(JavaThread* thr, jobject obj) {

    if (!obj)

        return NULL;

    ASSERT_OOPS_ALLOWED;

    oop oopObj = jniCheck::validate_handle(thr, obj);

    if (!oopObj) {

      ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

    }

    return oopObj;

}

// Warn if a class descriptor is in decorated form; class descriptors

// passed to JNI findClass should not be decorated unless they are

// array descriptors.

void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {

  if (name == NULL) return;  // implementation accepts NULL so just return

  size_t len = strlen(name);

  if (len >= 2 &&

      name[0] == JVM_SIGNATURE_CLASS &&            // 'L'

      name[len-1] == JVM_SIGNATURE_ENDCLASS ) {    // ';'

    char msg[JVM_MAXPATHLEN];

    jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name);

    ReportJNIWarning(thr, msg);

  }

}

klassOop jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) {

  ASSERT_OOPS_ALLOWED;

  oop mirror = jniCheck::validate_handle(thr, clazz);

  if (!mirror) {

    ReportJNIFatalError(thr, fatal_received_null_class);

  }

  if (mirror->klass() != SystemDictionary::class_klass()) {

    ReportJNIFatalError(thr, fatal_class_not_a_class);

  }

  klassOop k = java_lang_Class::as_klassOop(mirror);

  // Make allowances for primitive classes ...

  if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) {

    ReportJNIFatalError(thr, fatal_class_not_a_class);

  }

  return k;

}

void jniCheck::validate_throwable_klass(JavaThread* thr, klassOop klass) {

  ASSERT_OOPS_ALLOWED;

  assert(klass != NULL, "klass argument must have a value");

  if (!Klass::cast(klass)->oop_is_instance() ||

      !instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::throwable_klass())) {

    ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

  }

}

void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {

  /* validate the object being passed */

  ASSERT_OOPS_ALLOWED;

  jniCheck::validate_jmethod_id(thr, method_id);

  jniCheck::validate_object(thr, obj);

}

void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {

  /* validate the class being passed */

  ASSERT_OOPS_ALLOWED;

  jniCheck::validate_jmethod_id(thr, method_id);

  jniCheck::validate_class(thr, clazz, false);

}

/*

 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

 */

JNI_ENTRY_CHECKED(jclass,

  checked_jni_DefineClass(JNIEnv *env,

                          const char *name,

                          jobject loader,

                          const jbyte *buf,

                          jsize len))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_object(thr, loader);

    )

    jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jclass,

  checked_jni_FindClass(JNIEnv *env,

                        const char *name))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_class_descriptor(thr, name);

    )

    jclass result = UNCHECKED()->FindClass(env, name);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jmethodID,

  checked_jni_FromReflectedMethod(JNIEnv *env,

                                  jobject method))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_object(thr, method);

    )

    jmethodID result = UNCHECKED()->FromReflectedMethod(env, method);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jfieldID,

  checked_jni_FromReflectedField(JNIEnv *env,

                                 jobject field))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_object(thr, field);

    )

    jfieldID result = UNCHECKED()->FromReflectedField(env, field);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jobject,

  checked_jni_ToReflectedMethod(JNIEnv *env,

                                jclass cls,

                                jmethodID methodID,

                                jboolean isStatic))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_class(thr, cls, false);

      jniCheck::validate_jmethod_id(thr, methodID);

    )

    jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,

                                                    isStatic);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jclass,

  checked_jni_GetSuperclass(JNIEnv *env,

                            jclass sub))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_class(thr, sub, true);

    )

    jclass result = UNCHECKED()->GetSuperclass(env, sub);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jboolean,

  checked_jni_IsAssignableFrom(JNIEnv *env,

                               jclass sub,

                               jclass sup))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_class(thr, sub, true);

      jniCheck::validate_class(thr, sup, true);

    )

    jboolean result = UNCHECKED()->IsAssignableFrom(env, sub, sup);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jobject,

  checked_jni_ToReflectedField(JNIEnv *env,

                               jclass cls,

                               jfieldID fieldID,

                               jboolean isStatic))

    functionEnter(thr);

    IN_VM(

      jniCheck::validate_class(thr, cls, false);

    )

    jobject result = UNCHECKED()->ToReflectedField(env, cls, fieldID,

                                                   isStatic);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jint,

  checked_jni_Throw(JNIEnv *env,

                    jthrowable obj))

    functionEnter(thr);

    IN_VM(

      oop oopObj = jniCheck::validate_object(thr, obj);

      if (oopObj == NULL) {

        // Unchecked Throw tolerates a NULL obj, so just warn

        ReportJNIWarning(thr, "JNI Throw called with NULL throwable");

      } else {

        jniCheck::validate_throwable_klass(thr, oopObj->klass());

      }

    )

    jint result = UNCHECKED()->Throw(env, obj);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jint,

  checked_jni_ThrowNew(JNIEnv *env,

                       jclass clazz,

                       const char *msg))

    functionEnter(thr);

    IN_VM(

      klassOop k = jniCheck::validate_class(thr, clazz, false);

      assert(k != NULL, "validate_class shouldn't return NULL klassOop");

      jniCheck::validate_throwable_klass(thr, k);

    )

    jint result = UNCHECKED()->ThrowNew(env, clazz, msg);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(jthrowable,

  checked_jni_ExceptionOccurred(JNIEnv *env))

    functionEnterExceptionAllowed(thr);

    jthrowable result = UNCHECKED()->ExceptionOccurred(env);

    functionExit(env);

    return result;

JNI_END

JNI_ENTRY_CHECKED(void,

  checked_jni_ExceptionDescribe(JNIEnv *env))