/*

 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jni.h"

#include "prims/jniCheck.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/thread.inline.hpp"

#ifdef TARGET_ARCH_x86

# include "jniTypes_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "jniTypes_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "jniTypes_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "jniTypes_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "jniTypes_ppc.hpp"

#endif

// 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("%s", fatal_using_jnienv_in_nonjava);                      \

      os::abort(true);                                                   \

    }                                                                    \

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

    if (env != xenv) {                                                   \

      NativeReportJNIFatalError(thr, warn_wrong_jnienv);                 \

    }                                                                    \

    VM_ENTRY_BASE(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_non_weak_method = "non-weak 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_prim_type_array_expected = "Primitive type 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("%s", 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("%s", 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;

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

  /* check for proper subclass hierarchy */

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

  Klass* 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 (!id->find_local_field(&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);

  }

  Klass* 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 arrayOop

check_is_array(JavaThread* thr, jarray jArray)

{

  ASSERT_OOPS_ALLOWED;

  arrayOop aOop;

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

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

    ReportJNIFatalError(thr, fatal_non_array);

  }

  return aOop;

}

static inline arrayOop

check_is_primitive_array(JavaThread* thr, jarray jArray) {

  arrayOop aOop = check_is_array(thr, jArray);

  if (!aOop->is_typeArray()) {

     ReportJNIFatalError(thr, fatal_prim_type_array_expected);

  }

  return aOop;

}

static inline void

check_primitive_array_type(JavaThread* thr, jarray jArray, BasicType elementType)

{

  BasicType array_type;

  arrayOop aOop;

  aOop = check_is_primitive_array(thr, jArray);

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

  if (array_type != elementType) {

    ReportJNIFatalError(thr, fatal_element_type_mismatch);

  }

}

static inline void

check_is_obj_array(JavaThread* thr, jarray jArray) {

  arrayOop aOop = check_is_array(thr, jArray);

  if (!aOop->is_objArray()) {

    ReportJNIFatalError(thr, fatal_object_array_expected);

  }

}

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;

}

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

  ASSERT_OOPS_ALLOWED;

  // do the fast jmethodID check first

  Method* moop = Method::checked_resolve_jmethod_id(method_id);

  if (moop == NULL) {

    ReportJNIFatalError(thr, fatal_wrong_class_or_method);

  }

  // jmethodIDs are supposed to be weak handles in the class loader data,

  // but that can be expensive so check it last

  else if (!Method::is_method_id(method_id)) {

    ReportJNIFatalError(thr, fatal_non_weak_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);

  }

}

Klass* 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);

  }

  Klass* k = java_lang_Class::as_Klass(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, Klass* klass) {

  ASSERT_OOPS_ALLOWED;

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

  if (!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