/*

 * Copyright (c) 2014, 2018, 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/classFileStream.hpp"

#include "classfile/classListParser.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/classLoaderExt.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "classfile/verificationType.hpp"

#include "classfile/vmSymbols.hpp"

#include "logging/log.hpp"

#include "memory/allocation.hpp"

#include "memory/filemap.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/klass.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/stringUtils.hpp"

objArrayOop SystemDictionaryShared::_shared_protection_domains  =  NULL;

objArrayOop SystemDictionaryShared::_shared_jar_urls            =  NULL;

objArrayOop SystemDictionaryShared::_shared_jar_manifests       =  NULL;

oop SystemDictionaryShared::shared_protection_domain(int index) {

  return _shared_protection_domains->obj_at(index);

}

oop SystemDictionaryShared::shared_jar_url(int index) {

  return _shared_jar_urls->obj_at(index);

}

oop SystemDictionaryShared::shared_jar_manifest(int index) {

  return _shared_jar_manifests->obj_at(index);

}

Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) {

  Handle manifest ;

  if (shared_jar_manifest(shared_path_index) == NULL) {

    SharedClassPathEntry* ent = FileMapInfo::shared_path(shared_path_index);

    long size = ent->manifest_size();

    if (size <= 0) {

      return Handle();

    }

    // ByteArrayInputStream bais = new ByteArrayInputStream(buf);

    const char* src = ent->manifest();

    assert(src != NULL, "No Manifest data");

    typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_NH);

    typeArrayHandle bufhandle(THREAD, buf);

    ArrayAccess<>::arraycopy_from_native(reinterpret_cast<const jbyte*>(src),

                                         buf, typeArrayOopDesc::element_offset<jbyte>(0), size);

    Handle bais = JavaCalls::construct_new_instance(SystemDictionary::ByteArrayInputStream_klass(),

                      vmSymbols::byte_array_void_signature(),

                      bufhandle, CHECK_NH);

    // manifest = new Manifest(bais)

    manifest = JavaCalls::construct_new_instance(SystemDictionary::Jar_Manifest_klass(),

                      vmSymbols::input_stream_void_signature(),

                      bais, CHECK_NH);

    atomic_set_shared_jar_manifest(shared_path_index, manifest());

  }

  manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));

  assert(manifest.not_null(), "sanity");

  return manifest;

}

Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) {

  Handle url_h;

  if (shared_jar_url(shared_path_index) == NULL) {

    JavaValue result(T_OBJECT);

    const char* path = FileMapInfo::shared_path_name(shared_path_index);

    Handle path_string = java_lang_String::create_from_str(path, CHECK_(url_h));

    Klass* classLoaders_klass =

        SystemDictionary::jdk_internal_loader_ClassLoaders_klass();

    JavaCalls::call_static(&result, classLoaders_klass,

                           vmSymbols::toFileURL_name(),

                           vmSymbols::toFileURL_signature(),

                           path_string, CHECK_(url_h));

    atomic_set_shared_jar_url(shared_path_index, (oop)result.get_jobject());

  }

  url_h = Handle(THREAD, shared_jar_url(shared_path_index));

  assert(url_h.not_null(), "sanity");

  return url_h;

}

Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) {

  ResourceMark rm(THREAD);

  Handle pkgname_string;

  char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string());

  if (pkgname != NULL) { // Package prefix found

    StringUtils::replace_no_expand(pkgname, "/", ".");

    pkgname_string = java_lang_String::create_from_str(pkgname,

                                                       CHECK_(pkgname_string));

  }

  return pkgname_string;

}

// Define Package for shared app classes from JAR file and also checks for

// package sealing (all done in Java code)

// See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html

void SystemDictionaryShared::define_shared_package(Symbol*  class_name,

                                                   Handle class_loader,

                                                   Handle manifest,

                                                   Handle url,

                                                   TRAPS) {

  assert(SystemDictionary::is_system_class_loader(class_loader()), "unexpected class loader");

  // get_package_name() returns a NULL handle if the class is in unnamed package

  Handle pkgname_string = get_package_name(class_name, CHECK);

  if (pkgname_string.not_null()) {

    Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();

    JavaValue result(T_OBJECT);

    JavaCallArguments args(3);

    args.set_receiver(class_loader);

    args.push_oop(pkgname_string);

    args.push_oop(manifest);

    args.push_oop(url);

    JavaCalls::call_virtual(&result, app_classLoader_klass,

                            vmSymbols::defineOrCheckPackage_name(),

                            vmSymbols::defineOrCheckPackage_signature(),

                            &args,

                            CHECK);

  }

}

// Define Package for shared app/platform classes from named module

void SystemDictionaryShared::define_shared_package(Symbol* class_name,

                                                   Handle class_loader,

                                                   ModuleEntry* mod_entry,

                                                   TRAPS) {

  assert(mod_entry != NULL, "module_entry should not be NULL");

  Handle module_handle(THREAD, mod_entry->module());

  Handle pkg_name = get_package_name(class_name, CHECK);

  assert(pkg_name.not_null(), "Package should not be null for class in named module");

  Klass* classLoader_klass;

  if (SystemDictionary::is_system_class_loader(class_loader())) {

    classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();

  } else {

    assert(SystemDictionary::is_platform_class_loader(class_loader()), "unexpected classloader");

    classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();

  }

  JavaValue result(T_OBJECT);

  JavaCallArguments args(2);

  args.set_receiver(class_loader);

  args.push_oop(pkg_name);

  args.push_oop(module_handle);

  JavaCalls::call_virtual(&result, classLoader_klass,

                          vmSymbols::definePackage_name(),

                          vmSymbols::definePackage_signature(),

                          &args,

                          CHECK);

}

// Get the ProtectionDomain associated with the CodeSource from the classloader.

Handle SystemDictionaryShared::get_protection_domain_from_classloader(Handle class_loader,

                                                                      Handle url, TRAPS) {

  // CodeSource cs = new CodeSource(url, null);

  Handle cs = JavaCalls::construct_new_instance(SystemDictionary::CodeSource_klass(),

                  vmSymbols::url_code_signer_array_void_signature(),

                  url, Handle(), CHECK_NH);

  // protection_domain = SecureClassLoader.getProtectionDomain(cs);

  Klass* secureClassLoader_klass = SystemDictionary::SecureClassLoader_klass();

  JavaValue obj_result(T_OBJECT);

  JavaCalls::call_virtual(&obj_result, class_loader, secureClassLoader_klass,

                          vmSymbols::getProtectionDomain_name(),

                          vmSymbols::getProtectionDomain_signature(),

                          cs, CHECK_NH);

  return Handle(THREAD, (oop)obj_result.get_jobject());

}

// Returns the ProtectionDomain associated with the JAR file identified by the url.

Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,

                                                            int shared_path_index,

                                                            Handle url,

                                                            TRAPS) {

  Handle protection_domain;

  if (shared_protection_domain(shared_path_index) == NULL) {

    Handle pd = get_protection_domain_from_classloader(class_loader, url, THREAD);

    atomic_set_shared_protection_domain(shared_path_index, pd());

  }

  // Acquire from the cache because if another thread beats the current one to

  // set the shared protection_domain and the atomic_set fails, the current thread

  // needs to get the updated protection_domain from the cache.

  protection_domain = Handle(THREAD, shared_protection_domain(shared_path_index));

  assert(protection_domain.not_null(), "sanity");

  return protection_domain;

}

// Returns the ProtectionDomain associated with the moduleEntry.

Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,

                                                            ModuleEntry* mod, TRAPS) {

  ClassLoaderData *loader_data = mod->loader_data();

  Handle protection_domain;

  if (mod->shared_protection_domain() == NULL) {