jdk

1
/*
2
 * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#include "precompiled.hpp"
26
#include "jvm_io.h"
27
#include "runtime/arguments.hpp"
28
#include "runtime/interfaceSupport.inline.hpp"
29
#include "runtime/os.inline.hpp"
30
#include "runtime/semaphore.inline.hpp"
31
#include "runtime/thread.inline.hpp"
32
#include "utilities/zipLibrary.hpp"
33

34
 // Entry points in zip.dll for loading zip/jar file entries
35
typedef void**(*ZIP_Open_t)(const char* name, char** pmsg);
36
typedef void(*ZIP_Close_t)(jzfile* zip);
37
typedef jzentry* (*ZIP_FindEntry_t)(jzfile* zip, const char* name, jint* sizeP, jint* nameLen);
38
typedef jboolean(*ZIP_ReadEntry_t)(jzfile* zip, jzentry* entry, unsigned char* buf, char* namebuf);
39
typedef jint(*ZIP_CRC32_t)(jint crc, const jbyte* buf, jint len);
40
typedef const char* (*ZIP_GZip_InitParams_t)(size_t, size_t*, size_t*, int);
41
typedef size_t(*ZIP_GZip_Fully_t)(char*, size_t, char*, size_t, char*, size_t, int, char*, char const**);
42

43
static ZIP_Open_t ZIP_Open = nullptr;
44
static ZIP_Close_t ZIP_Close = nullptr;
45
static ZIP_FindEntry_t ZIP_FindEntry = nullptr;
46
static ZIP_ReadEntry_t ZIP_ReadEntry = nullptr;
47
static ZIP_CRC32_t ZIP_CRC32 = nullptr;
48
static ZIP_GZip_InitParams_t ZIP_GZip_InitParams = nullptr;
49
static ZIP_GZip_Fully_t ZIP_GZip_Fully = nullptr;
50

51
static void* _zip_handle = nullptr;
52
static bool _loaded = false;
53

54
static inline bool is_loaded() {
55
  return Atomic::load_acquire(&_loaded);
56
}
57

58
static inline bool not_loaded() {
59
  return !is_loaded();
60
}
61

62
static void* dll_lookup(const char* name, const char* path, bool vm_exit_on_failure) {
63
  assert(_zip_handle != nullptr, "invariant");
64
  void* func = os::dll_lookup(_zip_handle, name);
65
  if (func == nullptr && vm_exit_on_failure) {
66
    char msg[256] = "";
67
    jio_snprintf(&msg[0], sizeof msg, "Could not resolve \"%s\"", name);
68
    vm_exit_during_initialization(&msg[0], path);
69
  }
70
  return func;
71
}
72

73
static void store_function_pointers(const char* path, bool vm_exit_on_failure) {
74
  assert(_zip_handle != nullptr, "invariant");
75
  ZIP_Open = CAST_TO_FN_PTR(ZIP_Open_t, dll_lookup("ZIP_Open", path, vm_exit_on_failure));
76
  ZIP_Close = CAST_TO_FN_PTR(ZIP_Close_t, dll_lookup("ZIP_Close", path, vm_exit_on_failure));
77
  ZIP_FindEntry = CAST_TO_FN_PTR(ZIP_FindEntry_t, dll_lookup("ZIP_FindEntry", path, vm_exit_on_failure));
78
  ZIP_ReadEntry = CAST_TO_FN_PTR(ZIP_ReadEntry_t, dll_lookup("ZIP_ReadEntry", path, vm_exit_on_failure));
79
  ZIP_CRC32 = CAST_TO_FN_PTR(ZIP_CRC32_t, dll_lookup("ZIP_CRC32", path, vm_exit_on_failure));
80
  // The following entry points are most likely optional from a zip library implementation perspective.
81
  // Hence no vm_exit on a resolution failure. Further refactorings should investigate this,
82
  // and if possible, streamline setting all entry points consistently.
83
  ZIP_GZip_InitParams = CAST_TO_FN_PTR(ZIP_GZip_InitParams_t, dll_lookup("ZIP_GZip_InitParams", path, false));
84
  ZIP_GZip_Fully = CAST_TO_FN_PTR(ZIP_GZip_Fully_t, dll_lookup("ZIP_GZip_Fully", path, false));
85
}
86

87
static void load_zip_library(bool vm_exit_on_failure) {
88
  assert(!is_loaded(), "should not load zip library twice");
89
  char path[JVM_MAXPATHLEN];
90
  if (os::dll_locate_lib(&path[0], sizeof path, Arguments::get_dll_dir(), "zip")) {
91
    char ebuf[1024];
92
    _zip_handle = os::dll_load(&path[0], &ebuf[0], sizeof ebuf);
93
  }
94
  if (_zip_handle == nullptr) {
95
    if (vm_exit_on_failure) {
96
      vm_exit_during_initialization("Unable to load zip library", &path[0]);
97
    }
98
    return;
99
  }
100
  store_function_pointers(&path[0], vm_exit_on_failure);
101
  Atomic::release_store(&_loaded, true);
102
  assert(is_loaded(), "invariant");
103
}
104

105
//
106
// Helper mutex class that also ensures that java threads
107
// are in _thread_in_native when loading the zip library.
108
//
109
class ZipLibraryLoaderLock : public StackObj {
110
 private:
111
  static Semaphore _lock;
112
  JavaThread* _jt;
113
 public:
114
   ZipLibraryLoaderLock() : _jt(nullptr) {
115
    Thread* thread = Thread::current_or_null();
116
    if (thread != nullptr && thread->is_Java_thread()) {
117
      JavaThread* const jt = JavaThread::cast(thread);
118
      if (jt->thread_state() != _thread_in_native) {
119
        _jt = jt;
120
        ThreadStateTransition::transition_from_vm(jt, _thread_in_native, false);
121
      }
122
    }
123
    _lock.wait();
124
  }
125
  ~ZipLibraryLoaderLock() {
126
    _lock.signal();
127
    if (_jt != nullptr) {
128
      ThreadStateTransition::transition_from_native(_jt, _thread_in_vm, false);
129
    }
130
  }
131
};
132

133
Semaphore ZipLibraryLoaderLock::_lock(1);
134

135
static void initialize(bool vm_exit_on_failure = true) {
136
  if (is_loaded()) {
137
    return;
138
  }
139
  ZipLibraryLoaderLock lock;
140
  if (not_loaded()) {
141
    load_zip_library(vm_exit_on_failure);
142
  }
143
}
144

145
void** ZipLibrary::open(const char* name, char** pmsg) {
146
  initialize();
147
  assert(ZIP_Open != nullptr, "invariant");
148
  return ZIP_Open(name, pmsg);
149
}
150

151
void ZipLibrary::close(jzfile* zip) {
152
  assert(is_loaded(), "invariant");
153
  assert(ZIP_Close != nullptr, "invariant");
154
  ZIP_Close(zip);
155
}
156

157
jzentry* ZipLibrary::find_entry(jzfile* zip, const char* name, jint* sizeP, jint* nameLen) {
158
  initialize();
159
  assert(ZIP_FindEntry != nullptr, "invariant");
160
  return ZIP_FindEntry(zip, name, sizeP, nameLen);
161
}
162

163
jboolean ZipLibrary::read_entry(jzfile* zip, jzentry* entry, unsigned char* buf, char* namebuf) {
164
  initialize();
165
  assert(ZIP_ReadEntry != nullptr, "invariant");
166
  return ZIP_ReadEntry(zip, entry, buf, namebuf);
167
}
168

169
jint ZipLibrary::crc32(jint crc, const jbyte* buf, jint len) {
170
  initialize();
171
  assert(ZIP_CRC32 != nullptr, "invariant");
172
  return ZIP_CRC32(crc, buf, len);
173
}
174

175
const char* ZipLibrary::init_params(size_t block_size, size_t* needed_out_size, size_t* needed_tmp_size, int level) {
176
  initialize(false);
177
  if (ZIP_GZip_InitParams == nullptr) {
178
    return "Cannot get ZIP_GZip_InitParams function";
179
  }
180
  return ZIP_GZip_InitParams(block_size, needed_out_size, needed_tmp_size, level);
181
}
182

183
size_t ZipLibrary::compress(char* in, size_t in_size, char* out, size_t out_size, char* tmp, size_t tmp_size, int level, char* buf, const char** pmsg) {
184
  initialize(false);
185
  if (ZIP_GZip_Fully == nullptr) {
186
    *pmsg = "Cannot get ZIP_GZip_Fully function";
187
    return 0;
188
  }
189
  return ZIP_GZip_Fully(in, in_size, out, out_size, tmp, tmp_size, level, buf, pmsg);
190
}
191

192
void* ZipLibrary::handle() {
193
  initialize();
194
  assert(is_loaded(), "invariant");
195
  assert(_zip_handle != nullptr, "invariant");
196
  return _zip_handle;
197
}
198