/*

 * Copyright (c) 1997, 2019, 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 "jvm.h"

#include "jimage.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.inline.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderExt.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/modules.hpp"

#include "classfile/packageEntry.hpp"

#include "classfile/klassFactory.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/oopMapCache.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "logging/logTag.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/method.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "runtime/vm_version.hpp"

#include "services/management.hpp"

#include "services/threadService.hpp"

#include "utilities/classpathStream.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/macros.hpp"

// Entry points in zip.dll for loading zip/jar file entries

typedef void * * (*ZipOpen_t)(const char *name, char **pmsg);

typedef jzentry* (*FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen);

typedef jboolean (*ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf);

typedef jzentry* (*GetNextEntry_t)(jzfile *zip, jint n);

typedef jint     (*Crc32_t)(jint crc, const jbyte *buf, jint len);

static ZipOpen_t         ZipOpen            = NULL;

static ZipClose_t        ZipClose           = NULL;

static FindEntry_t       FindEntry          = NULL;

static ReadEntry_t       ReadEntry          = NULL;

static GetNextEntry_t    GetNextEntry       = NULL;

static Crc32_t           Crc32              = NULL;

// Entry points for jimage.dll for loading jimage file entries

static JImageOpen_t                    JImageOpen             = NULL;

static JImageClose_t                   JImageClose            = NULL;

static JImagePackageToModule_t         JImagePackageToModule  = NULL;

static JImageFindResource_t            JImageFindResource     = NULL;

static JImageGetResource_t             JImageGetResource      = NULL;

static JImageResourceIterator_t        JImageResourceIterator = NULL;

// Globals

PerfCounter*    ClassLoader::_perf_accumulated_time = NULL;

PerfCounter*    ClassLoader::_perf_classes_inited = NULL;

PerfCounter*    ClassLoader::_perf_class_init_time = NULL;

PerfCounter*    ClassLoader::_perf_class_init_selftime = NULL;

PerfCounter*    ClassLoader::_perf_classes_verified = NULL;

PerfCounter*    ClassLoader::_perf_class_verify_time = NULL;

PerfCounter*    ClassLoader::_perf_class_verify_selftime = NULL;

PerfCounter*    ClassLoader::_perf_classes_linked = NULL;

PerfCounter*    ClassLoader::_perf_class_link_time = NULL;

PerfCounter*    ClassLoader::_perf_class_link_selftime = NULL;

PerfCounter*    ClassLoader::_perf_class_parse_time = NULL;

PerfCounter*    ClassLoader::_perf_class_parse_selftime = NULL;

PerfCounter*    ClassLoader::_perf_sys_class_lookup_time = NULL;

PerfCounter*    ClassLoader::_perf_shared_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_sys_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_selftime = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_count = NULL;

PerfCounter*    ClassLoader::_perf_define_appclasses = NULL;

PerfCounter*    ClassLoader::_perf_define_appclass_time = NULL;

PerfCounter*    ClassLoader::_perf_define_appclass_selftime = NULL;

PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = NULL;

PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = NULL;

PerfCounter*    ClassLoader::_sync_systemLoaderLockContentionRate = NULL;

PerfCounter*    ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;

PerfCounter*    ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;

GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = NULL;

GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = NULL;

ClassPathEntry* ClassLoader::_jrt_entry = NULL;

ClassPathEntry* ClassLoader::_first_append_entry = NULL;

ClassPathEntry* ClassLoader::_last_append_entry  = NULL;

#if INCLUDE_CDS

ClassPathEntry* ClassLoader::_app_classpath_entries = NULL;

ClassPathEntry* ClassLoader::_last_app_classpath_entry = NULL;

ClassPathEntry* ClassLoader::_module_path_entries = NULL;

ClassPathEntry* ClassLoader::_last_module_path_entry = NULL;

#endif

// helper routines

bool string_starts_with(const char* str, const char* str_to_find) {

  size_t str_len = strlen(str);

  size_t str_to_find_len = strlen(str_to_find);

  if (str_to_find_len > str_len) {

    return false;

  }

  return (strncmp(str, str_to_find, str_to_find_len) == 0);

}

static const char* get_jimage_version_string() {

  static char version_string[10] = "";

  if (version_string[0] == '\0') {

    jio_snprintf(version_string, sizeof(version_string), "%d.%d",

                 VM_Version::vm_major_version(), VM_Version::vm_minor_version());

  }

  return (const char*)version_string;

}

bool ClassLoader::string_ends_with(const char* str, const char* str_to_find) {

  size_t str_len = strlen(str);

  size_t str_to_find_len = strlen(str_to_find);

  if (str_to_find_len > str_len) {

    return false;

  }

  return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0);

}

// Used to obtain the package name from a fully qualified class name.

// It is the responsibility of the caller to establish a ResourceMark.

const char* ClassLoader::package_from_name(const char* const class_name, bool* bad_class_name) {

  if (class_name == NULL) {

    if (bad_class_name != NULL) {

      *bad_class_name = true;

    }

    return NULL;

  }

  if (bad_class_name != NULL) {

    *bad_class_name = false;

  }

  const char* const last_slash = strrchr(class_name, JVM_SIGNATURE_SLASH);

  if (last_slash == NULL) {

    // No package name

    return NULL;

  }

  char* class_name_ptr = (char*) class_name;

  // Skip over '['s

  if (*class_name_ptr == JVM_SIGNATURE_ARRAY) {

    do {

      class_name_ptr++;

    } while (*class_name_ptr == JVM_SIGNATURE_ARRAY);

    // Fully qualified class names should not contain a 'L'.

    // Set bad_class_name to true to indicate that the package name

    // could not be obtained due to an error condition.

    // In this situation, is_same_class_package returns false.

    if (*class_name_ptr == JVM_SIGNATURE_CLASS) {

      if (bad_class_name != NULL) {

        *bad_class_name = true;

      }

      return NULL;

    }

  }

  int length = last_slash - class_name_ptr;

  // A class name could have just the slash character in the name.

  if (length <= 0) {

    // No package name

    if (bad_class_name != NULL) {

      *bad_class_name = true;

    }

    return NULL;

  }

  // drop name after last slash (including slash)

  // Ex., "java/lang/String.class" => "java/lang"

  char* pkg_name = NEW_RESOURCE_ARRAY(char, length + 1);

  strncpy(pkg_name, class_name_ptr, length);

  *(pkg_name+length) = '\0';

  return (const char *)pkg_name;

}

// Given a fully qualified class name, find its defining package in the class loader's

// package entry table.

PackageEntry* ClassLoader::get_package_entry(const char* class_name, ClassLoaderData* loader_data, TRAPS) {

  ResourceMark rm(THREAD);

  const char *pkg_name = ClassLoader::package_from_name(class_name);

  if (pkg_name == NULL) {

    return NULL;

  }

  PackageEntryTable* pkgEntryTable = loader_data->packages();

  TempNewSymbol pkg_symbol = SymbolTable::new_symbol(pkg_name);

  return pkgEntryTable->lookup_only(pkg_symbol);

}

const char* ClassPathEntry::copy_path(const char* path) {

  char* copy = NEW_C_HEAP_ARRAY(char, strlen(path)+1, mtClass);

  strcpy(copy, path);

  return copy;

}

ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {

  // construct full path name

  assert((_dir != NULL) && (name != NULL), "sanity");

  size_t path_len = strlen(_dir) + strlen(name) + strlen(os::file_separator()) + 1;

  char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, path_len);

  int len = jio_snprintf(path, path_len, "%s%s%s", _dir, os::file_separator(), name);

  assert(len == (int)(path_len - 1), "sanity");

  // check if file exists

  struct stat st;

  if (os::stat(path, &st) == 0) {

    // found file, open it

    int file_handle = os::open(path, 0, 0);

    if (file_handle != -1) {

      // read contents into resource array

      u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);

      size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);

      // close file

      os::close(file_handle);

      // construct ClassFileStream

      if (num_read == (size_t)st.st_size) {

        if (UsePerfData) {

          ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);

        }

        FREE_RESOURCE_ARRAY(char, path, path_len);

        // Resource allocated

        return new ClassFileStream(buffer,

                                   st.st_size,

                                   _dir,

                                   ClassFileStream::verify);

      }

    }

  }

  FREE_RESOURCE_ARRAY(char, path, path_len);

  return NULL;

}

ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name,

                                     bool is_boot_append, bool from_class_path_attr) : ClassPathEntry() {

  _zip = zip;

  _zip_name = copy_path(zip_name);

  _from_class_path_attr = from_class_path_attr;

}

ClassPathZipEntry::~ClassPathZipEntry() {

  FREE_C_HEAP_ARRAY(char, _zip_name);

}

u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {

    // enable call to C land

  JavaThread* thread = JavaThread::current();

  ThreadToNativeFromVM ttn(thread);

  // check whether zip archive contains name

  jint name_len;

  jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);

  if (entry == NULL) return NULL;

  u1* buffer;

  char name_buf[128];

  char* filename;

  if (name_len < 128) {

    filename = name_buf;

  } else {

    filename = NEW_RESOURCE_ARRAY(char, name_len + 1);

  }

  // read contents into resource array

  int size = (*filesize) + ((nul_terminate) ? 1 : 0);

  buffer = NEW_RESOURCE_ARRAY(u1, size);

  if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;

  // return result

  if (nul_terminate) {

    buffer[*filesize] = 0;

  }

  return buffer;

}

ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {

  jint filesize;

  u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);

  if (buffer == NULL) {

    return NULL;

  }

  if (UsePerfData) {

    ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);

  }

  // Resource allocated

  return new ClassFileStream(buffer,

                             filesize,

                             _zip_name,

                             ClassFileStream::verify);

}

// invoke function for each entry in the zip file

void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {

  JavaThread* thread = JavaThread::current();

  HandleMark  handle_mark(thread);

  ThreadToNativeFromVM ttn(thread);

  for (int n = 0; ; n++) {

    jzentry * ze = ((*GetNextEntry)(_zip, n));

    if (ze == NULL) break;

    (*f)(ze->name, context);

  }

}

DEBUG_ONLY(ClassPathImageEntry* ClassPathImageEntry::_singleton = NULL;)

void ClassPathImageEntry::close_jimage() {

  if (_jimage != NULL) {

    (*JImageClose)(_jimage);

    _jimage = NULL;

  }

}

ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) :

  ClassPathEntry(),

  _jimage(jimage) {

  guarantee(jimage != NULL, "jimage file is null");

  guarantee(name != NULL, "jimage file name is null");

  assert(_singleton == NULL, "VM supports only one jimage");

  DEBUG_ONLY(_singleton = this);

  size_t len = strlen(name) + 1;

  _name = copy_path(name);

}

ClassPathImageEntry::~ClassPathImageEntry() {

  assert(_singleton == this, "must be");

  DEBUG_ONLY(_singleton = NULL);

  FREE_C_HEAP_ARRAY(const char, _name);

  if (_jimage != NULL) {

    (*JImageClose)(_jimage);

    _jimage = NULL;

  }

}

ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {

  return open_stream_for_loader(name, ClassLoaderData::the_null_class_loader_data(), THREAD);

}

// For a class in a named module, look it up in the jimage file using this syntax:

//    /<module-name>/<package-name>/<base-class>

//

// Assumptions:

//     1. There are no unnamed modules in the jimage file.

//     2. A package is in at most one module in the jimage file.

//

ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) {

  jlong size;

  JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size);

  if (location == 0) {

    ResourceMark rm;

    const char* pkg_name = ClassLoader::package_from_name(name);

    if (pkg_name != NULL) {

      if (!Universe::is_module_initialized()) {

        location = (*JImageFindResource)(_jimage, JAVA_BASE_NAME, get_jimage_version_string(), name, &size);

      } else {

        PackageEntry* package_entry = ClassLoader::get_package_entry(name, loader_data, CHECK_NULL);

        if (package_entry != NULL) {

          ResourceMark rm;

          // Get the module name

          ModuleEntry* module = package_entry->module();

          assert(module != NULL, "Boot classLoader package missing module");

          assert(module->is_named(), "Boot classLoader package is in unnamed module");

          const char* module_name = module->name()->as_C_string();

          if (module_name != NULL) {

            location = (*JImageFindResource)(_jimage, module_name, get_jimage_version_string(), name, &size);

          }

        }

      }

    }

  }

  if (location != 0) {

    if (UsePerfData) {

      ClassLoader::perf_sys_classfile_bytes_read()->inc(size);

    }

    char* data = NEW_RESOURCE_ARRAY(char, size);

    (*JImageGetResource)(_jimage, location, data, size);

    // Resource allocated

    assert(this == (ClassPathImageEntry*)ClassLoader::get_jrt_entry(), "must be");

    return new ClassFileStream((u1*)data,

                               (int)size,

                               _name,

                               ClassFileStream::verify,

                               true); // from_boot_loader_modules_image

  }

  return NULL;

}

JImageLocationRef ClassLoader::jimage_find_resource(JImageFile* jf,

                                                    const char* module_name,

                                                    const char* file_name,

                                                    jlong &size) {

  return ((*JImageFindResource)(jf, module_name, get_jimage_version_string(), file_name, &size));

}

bool ClassPathImageEntry::is_modules_image() const {

  assert(this == _singleton, "VM supports a single jimage");

  assert(this == (ClassPathImageEntry*)ClassLoader::get_jrt_entry(), "must be used for jrt entry");

  return true;

}

#if INCLUDE_CDS

void ClassLoader::exit_with_path_failure(const char* error, const char* message) {

  Arguments::assert_is_dumping_archive();

  tty->print_cr("Hint: enable -Xlog:class+path=info to diagnose the failure");

  vm_exit_during_initialization(error, message);

}

#endif

ModuleClassPathList::ModuleClassPathList(Symbol* module_name) {

  _module_name = module_name;

  _module_first_entry = NULL;

  _module_last_entry = NULL;

}

ModuleClassPathList::~ModuleClassPathList() {

  // Clean out each ClassPathEntry on list

  ClassPathEntry* e = _module_first_entry;

  while (e != NULL) {

    ClassPathEntry* next_entry = e->next();

    delete e;

    e = next_entry;

  }

}

void ModuleClassPathList::add_to_list(ClassPathEntry* new_entry) {

  if (new_entry != NULL) {

    if (_module_last_entry == NULL) {

      _module_first_entry = _module_last_entry = new_entry;

    } else {

      _module_last_entry->set_next(new_entry);

      _module_last_entry = new_entry;

    }