/*

 * Copyright (c) 2001, 2016, 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/javaClasses.inline.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "memory/guardedMemory.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"

// Complain every extra number of unplanned local refs

#define CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD 32

// 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*) Thread::current_or_null();           \

    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_descriptor1 = "JNI FindClass received a bad class descriptor \"";

static const char * warn_bad_class_descriptor2 = "\".  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

 */

/**

 * Check whether or not a programmer has actually checked for exceptions. According

 * to the JNI Specification ("jni/spec/design.html#java_exceptions"):

 *

 * There are two cases where the programmer needs to check for exceptions without

 * being able to first check an error code:

 *

 * - The JNI functions that invoke a Java method return the result of the Java method.

 * The programmer must call ExceptionOccurred() to check for possible exceptions

 * that occurred during the execution of the Java method.

 *

 * - Some of the JNI array access functions do not return an error code, but may

 * throw an ArrayIndexOutOfBoundsException or ArrayStoreException.

 *

 * In all other cases, a non-error return value guarantees that no exceptions have been thrown.

 *

 * Programmers often defend against ArrayIndexOutOfBoundsException, so warning

 * for these functions would be pedantic.

 */

static inline void

check_pending_exception(JavaThread* thr) {

  if (thr->has_pending_exception()) {

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

  }

  if (thr->is_pending_jni_exception_check()) {

    IN_VM(

      tty->print_cr("WARNING in native method: JNI call made without checking exceptions when required to from %s",

        thr->get_pending_jni_exception_check());

      thr->print_stack();

    )

    thr->clear_pending_jni_exception_check(); // Just complain once

  }

}

/**

 * Add to the planned number of handles. I.e. plus current live & warning threshold

 */

static inline void

add_planned_handle_capacity(JNIHandleBlock* handles, size_t capacity) {

  handles->set_planned_capacity(capacity +

                                handles->get_number_of_live_handles() +

                                CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);

}

static inline void

functionEnterCritical(JavaThread* thr)

{

  check_pending_exception(thr);

}

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

  }

  check_pending_exception(thr);

}

static inline void

functionEnterExceptionAllowed(JavaThread* thr)

{

  if (thr->in_critical()) {

    tty->print_cr("%s", warn_other_function_in_critical);

  }

}

static inline void

functionExit(JavaThread* thr)

{

  JNIHandleBlock* handles = thr->active_handles();

  size_t planned_capacity = handles->get_planned_capacity();

  size_t live_handles = handles->get_number_of_live_handles();

  if (live_handles > planned_capacity) {

    IN_VM(

      thr->print_stack();

    )

    // Complain just the once, reset to current + warn threshold

    add_planned_handle_capacity(handles, 0);

  }

}

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

  }

}

/*

 * Copy and wrap array elements for bounds checking.

 * Remember the original elements (GuardedMemory::get_tag())

 */

static void* check_jni_wrap_copy_array(JavaThread* thr, jarray array,

    void* orig_elements) {

  void* result;

  IN_VM(

    oop a = JNIHandles::resolve_non_null(array);

    size_t len = arrayOop(a)->length() <<

        TypeArrayKlass::cast(a->klass())->log2_element_size();

    result = GuardedMemory::wrap_copy(orig_elements, len, orig_elements);

  )

  return result;

}

static void* check_wrapped_array(JavaThread* thr, const char* fn_name,

    void* obj, void* carray, size_t* rsz) {

  if (carray == NULL) {

    tty->print_cr("%s: elements vector NULL" PTR_FORMAT, fn_name, p2i(obj));

    NativeReportJNIFatalError(thr, "Elements vector NULL");

  }

  GuardedMemory guarded(carray);

  void* orig_result = guarded.get_tag();

  if (!guarded.verify_guards()) {

    tty->print_cr("ReleasePrimitiveArrayCritical: release array failed bounds "

        "check, incorrect pointer returned ? array: " PTR_FORMAT " carray: "

        PTR_FORMAT, p2i(obj), p2i(carray));

    guarded.print_on(tty);

    NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "

        "failed bounds check");

  }

  if (orig_result == NULL) {

    tty->print_cr("ReleasePrimitiveArrayCritical: unrecognized elements. array: "

        PTR_FORMAT " carray: " PTR_FORMAT, p2i(obj), p2i(carray));

    guarded.print_on(tty);

    NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "

        "unrecognized elements");

  }

  if (rsz != NULL) {

    *rsz = guarded.get_user_size();

  }

  return orig_result;

}

static void* check_wrapped_array_release(JavaThread* thr, const char* fn_name,

    void* obj, void* carray, jint mode) {

  size_t sz;

  void* orig_result = check_wrapped_array(thr, fn_name, obj, carray, &sz);

  switch (mode) {

  case 0:

    memcpy(orig_result, carray, sz);

    GuardedMemory::free_copy(carray);

    break;

  case JNI_COMMIT:

    memcpy(orig_result, carray, sz);

    break;

  case JNI_ABORT:

    GuardedMemory::free_copy(carray);

    break;

  default:

    tty->print_cr("%s: Unrecognized mode %i releasing array "

        PTR_FORMAT " elements " PTR_FORMAT, fn_name, mode, p2i(obj), p2i(carray));

    NativeReportJNIFatalError(thr, "Unrecognized array release mode");

  }

  return orig_result;

}

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, "%s%s%s",

                 warn_bad_class_descriptor1, name, warn_bad_class_descriptor2);

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