1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // Uncomment for verbose logging.
18 // #define LOG_NDEBUG 0
19 #define LOG_TAG "webviewchromiumloader"
20
21 #include <dlfcn.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/mman.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31
32 #include <jni.h>
33 #include <android/dlext.h>
34 #include <nativeloader/native_loader.h>
35 #include <utils/Log.h>
36
37 #define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
38
39 namespace android {
40 namespace {
41
42 void* gReservedAddress = NULL;
43 size_t gReservedSize = 0;
44
45 jint LIBLOAD_SUCCESS;
46 jint LIBLOAD_FAILED_TO_OPEN_RELRO_FILE;
47 jint LIBLOAD_FAILED_TO_LOAD_LIBRARY;
48 jint LIBLOAD_FAILED_JNI_CALL;
49 jint LIBLOAD_FAILED_TO_FIND_NAMESPACE;
50
DoReserveAddressSpace(jlong size)51 jboolean DoReserveAddressSpace(jlong size) {
52 size_t vsize = static_cast<size_t>(size);
53
54 void* addr = mmap(NULL, vsize, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
55 if (addr == MAP_FAILED) {
56 ALOGE("Failed to reserve %zd bytes of address space for future load of "
57 "libwebviewchromium.so: %s",
58 vsize, strerror(errno));
59 return JNI_FALSE;
60 }
61 gReservedAddress = addr;
62 gReservedSize = vsize;
63 ALOGV("Reserved %zd bytes at %p", vsize, addr);
64 return JNI_TRUE;
65 }
66
DoCreateRelroFile(const char * lib,const char * relro)67 jboolean DoCreateRelroFile(const char* lib, const char* relro) {
68 // Try to unlink the old file, since if this is being called, the old one is
69 // obsolete.
70 if (unlink(relro) != 0 && errno != ENOENT) {
71 // If something went wrong other than the file not existing, log a warning
72 // but continue anyway in the hope that we can successfully overwrite the
73 // existing file with rename() later.
74 ALOGW("Failed to unlink old file %s: %s", relro, strerror(errno));
75 }
76 static const char tmpsuffix[] = ".XXXXXX";
77 char relro_tmp[strlen(relro) + sizeof(tmpsuffix)];
78 strlcpy(relro_tmp, relro, sizeof(relro_tmp));
79 strlcat(relro_tmp, tmpsuffix, sizeof(relro_tmp));
80 int tmp_fd = TEMP_FAILURE_RETRY(mkstemp(relro_tmp));
81 if (tmp_fd == -1) {
82 ALOGE("Failed to create temporary file %s: %s", relro_tmp, strerror(errno));
83 return JNI_FALSE;
84 }
85 android_dlextinfo extinfo;
86 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS | ANDROID_DLEXT_WRITE_RELRO;
87 extinfo.reserved_addr = gReservedAddress;
88 extinfo.reserved_size = gReservedSize;
89 extinfo.relro_fd = tmp_fd;
90 void* handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo);
91 int close_result = close(tmp_fd);
92 if (handle == NULL) {
93 ALOGE("Failed to load library %s: %s", lib, dlerror());
94 unlink(relro_tmp);
95 return JNI_FALSE;
96 }
97 if (close_result != 0 ||
98 chmod(relro_tmp, S_IRUSR | S_IRGRP | S_IROTH) != 0 ||
99 rename(relro_tmp, relro) != 0) {
100 ALOGE("Failed to update relro file %s: %s", relro, strerror(errno));
101 unlink(relro_tmp);
102 return JNI_FALSE;
103 }
104 ALOGV("Created relro file %s for library %s", relro, lib);
105 return JNI_TRUE;
106 }
107
DoLoadWithRelroFile(JNIEnv * env,const char * lib,const char * relro,jobject clazzLoader)108 jint DoLoadWithRelroFile(JNIEnv* env, const char* lib, const char* relro,
109 jobject clazzLoader) {
110 int relro_fd = TEMP_FAILURE_RETRY(open(relro, O_RDONLY));
111 if (relro_fd == -1) {
112 ALOGE("Failed to open relro file %s: %s", relro, strerror(errno));
113 return LIBLOAD_FAILED_TO_OPEN_RELRO_FILE;
114 }
115 android_namespace_t* ns =
116 android::FindNamespaceByClassLoader(env, clazzLoader);
117 if (ns == NULL) {
118 ALOGE("Failed to find classloader namespace");
119 return LIBLOAD_FAILED_TO_FIND_NAMESPACE;
120 }
121 android_dlextinfo extinfo;
122 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS | ANDROID_DLEXT_USE_RELRO |
123 ANDROID_DLEXT_USE_NAMESPACE;
124 extinfo.reserved_addr = gReservedAddress;
125 extinfo.reserved_size = gReservedSize;
126 extinfo.relro_fd = relro_fd;
127 extinfo.library_namespace = ns;
128 void* handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo);
129 close(relro_fd);
130 if (handle == NULL) {
131 ALOGE("Failed to load library %s: %s", lib, dlerror());
132 return LIBLOAD_FAILED_TO_LOAD_LIBRARY;
133 }
134 ALOGV("Loaded library %s with relro file %s", lib, relro);
135 return LIBLOAD_SUCCESS;
136 }
137
138 /******************************************************************************/
139 /* JNI wrappers - handle string lifetimes and 32/64 ABI choice */
140 /******************************************************************************/
141
ReserveAddressSpace(JNIEnv *,jclass,jlong size)142 jboolean ReserveAddressSpace(JNIEnv*, jclass, jlong size) {
143 return DoReserveAddressSpace(size);
144 }
145
CreateRelroFile(JNIEnv * env,jclass,jstring lib32,jstring lib64,jstring relro32,jstring relro64)146 jboolean CreateRelroFile(JNIEnv* env, jclass, jstring lib32, jstring lib64,
147 jstring relro32, jstring relro64) {
148 #ifdef __LP64__
149 jstring lib = lib64;
150 jstring relro = relro64;
151 (void)lib32; (void)relro32;
152 #else
153 jstring lib = lib32;
154 jstring relro = relro32;
155 (void)lib64; (void)relro64;
156 #endif
157 jboolean ret = JNI_FALSE;
158 const char* lib_utf8 = env->GetStringUTFChars(lib, NULL);
159 if (lib_utf8 != NULL) {
160 const char* relro_utf8 = env->GetStringUTFChars(relro, NULL);
161 if (relro_utf8 != NULL) {
162 ret = DoCreateRelroFile(lib_utf8, relro_utf8);
163 env->ReleaseStringUTFChars(relro, relro_utf8);
164 }
165 env->ReleaseStringUTFChars(lib, lib_utf8);
166 }
167 return ret;
168 }
169
LoadWithRelroFile(JNIEnv * env,jclass,jstring lib,jstring relro32,jstring relro64,jobject clazzLoader)170 jint LoadWithRelroFile(JNIEnv* env, jclass, jstring lib, jstring relro32,
171 jstring relro64, jobject clazzLoader) {
172 #ifdef __LP64__
173 jstring relro = relro64;
174 (void)relro32;
175 #else
176 jstring relro = relro32;
177 (void)relro64;
178 #endif
179 jint ret = LIBLOAD_FAILED_JNI_CALL;
180 const char* lib_utf8 = env->GetStringUTFChars(lib, NULL);
181 if (lib_utf8 != NULL) {
182 const char* relro_utf8 = env->GetStringUTFChars(relro, NULL);
183 if (relro_utf8 != NULL) {
184 ret = DoLoadWithRelroFile(env, lib_utf8, relro_utf8, clazzLoader);
185 env->ReleaseStringUTFChars(relro, relro_utf8);
186 }
187 env->ReleaseStringUTFChars(lib, lib_utf8);
188 }
189 return ret;
190 }
191
192 const char kWebViewFactoryClassName[] = "android/webkit/WebViewFactory";
193 const char kWebViewLibraryLoaderClassName[] =
194 "android/webkit/WebViewLibraryLoader";
195 const JNINativeMethod kJniMethods[] = {
196 { "nativeReserveAddressSpace", "(J)Z",
197 reinterpret_cast<void*>(ReserveAddressSpace) },
198 { "nativeCreateRelroFile",
199 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
200 reinterpret_cast<void*>(CreateRelroFile) },
201 { "nativeLoadWithRelroFile",
202 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/ClassLoader;)I",
203 reinterpret_cast<void*>(LoadWithRelroFile) },
204 };
205
206 } // namespace
207
RegisterWebViewFactory(JNIEnv * env)208 void RegisterWebViewFactory(JNIEnv* env) {
209 // If either of these fail, it will set an exception that will be thrown on
210 // return, so no need to handle errors here.
211 jclass clazz = env->FindClass(kWebViewFactoryClassName);
212 if (clazz) {
213 LIBLOAD_SUCCESS = env->GetStaticIntField(
214 clazz,
215 env->GetStaticFieldID(clazz, "LIBLOAD_SUCCESS", "I"));
216
217 LIBLOAD_FAILED_TO_OPEN_RELRO_FILE = env->GetStaticIntField(
218 clazz,
219 env->GetStaticFieldID(clazz, "LIBLOAD_FAILED_TO_OPEN_RELRO_FILE", "I"));
220
221 LIBLOAD_FAILED_TO_LOAD_LIBRARY = env->GetStaticIntField(
222 clazz,
223 env->GetStaticFieldID(clazz, "LIBLOAD_FAILED_TO_LOAD_LIBRARY", "I"));
224
225 LIBLOAD_FAILED_JNI_CALL = env->GetStaticIntField(
226 clazz,
227 env->GetStaticFieldID(clazz, "LIBLOAD_FAILED_JNI_CALL", "I"));
228
229 LIBLOAD_FAILED_TO_FIND_NAMESPACE = env->GetStaticIntField(
230 clazz,
231 env->GetStaticFieldID(clazz, "LIBLOAD_FAILED_TO_FIND_NAMESPACE", "I"));
232 }
233 }
234
RegisterWebViewLibraryLoader(JNIEnv * env)235 void RegisterWebViewLibraryLoader(JNIEnv* env) {
236 // If either of these fail, it will set an exception that will be thrown on
237 // return, so no need to handle errors here.
238 jclass clazz = env->FindClass(kWebViewLibraryLoaderClassName);
239 if (clazz) {
240 env->RegisterNatives(clazz, kJniMethods, NELEM(kJniMethods));
241 }
242 }
243
244 } // namespace android
245
JNI_OnLoad(JavaVM * vm,void *)246 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
247 JNIEnv* env = NULL;
248 if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
249 ALOGE("GetEnv failed");
250 return JNI_ERR;
251 }
252 android::RegisterWebViewFactory(env);
253 // Ensure there isn't a pending Java exception before registering methods from
254 // WebViewLibraryLoader
255 if (!env->ExceptionCheck()) {
256 android::RegisterWebViewLibraryLoader(env);
257 }
258 return JNI_VERSION_1_6;
259 }
260