2 * Copyright (C) 2011 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define LOG_TAG "NativeLibraryHelper"
18 //#define LOG_NDEBUG 0
20 #include <android_runtime/AndroidRuntime.h>
22 #include <utils/Log.h>
23 #include <androidfw/ZipFileRO.h>
24 #include <ScopedUtfChars.h>
34 #include <sys/types.h>
37 #define APK_LIB "lib/"
38 #define APK_LIB_LEN (sizeof(APK_LIB) - 1)
40 #define LIB_PREFIX "/lib"
41 #define LIB_PREFIX_LEN (sizeof(LIB_PREFIX) - 1)
43 #define LIB_SUFFIX ".so"
44 #define LIB_SUFFIX_LEN (sizeof(LIB_SUFFIX) - 1)
46 #define GDBSERVER "gdbserver"
47 #define GDBSERVER_LEN (sizeof(GDBSERVER) - 1)
49 #define TMP_FILE_PATTERN "/tmp.XXXXXX"
50 #define TMP_FILE_PATTERN_LEN (sizeof(TMP_FILE_PATTERN) - 1)
54 // These match PackageManager.java install codes
56 INSTALL_SUCCEEDED = 1,
57 INSTALL_FAILED_INVALID_APK = -2,
58 INSTALL_FAILED_INSUFFICIENT_STORAGE = -4,
59 INSTALL_FAILED_CONTAINER_ERROR = -18,
60 INSTALL_FAILED_INTERNAL_ERROR = -110,
63 typedef install_status_t (*iterFunc)(JNIEnv*, void*, ZipFileRO*, ZipEntryRO, const char*);
65 // Equivalent to isFilenameSafe
67 isFilenameSafe(const char* filename)
71 switch (*(filename + offset)) {
74 // If we've reached the end, all the other characters are good.
91 // We found something that is not good.
95 // Should not reach here.
99 isFileDifferent(const char* filePath, size_t fileSize, time_t modifiedTime,
100 long zipCrc, struct stat64* st)
102 if (lstat64(filePath, st) < 0) {
103 // File is not found or cannot be read.
104 ALOGV("Couldn't stat %s, copying: %s\n", filePath, strerror(errno));
108 if (!S_ISREG(st->st_mode)) {
112 if (st->st_size != fileSize) {
116 // For some reason, bionic doesn't define st_mtime as time_t
117 if (time_t(st->st_mtime) != modifiedTime) {
118 ALOGV("mod time doesn't match: %ld vs. %ld\n", st->st_mtime, modifiedTime);
122 int fd = TEMP_FAILURE_RETRY(open(filePath, O_RDONLY));
124 ALOGV("Couldn't open file %s: %s", filePath, strerror(errno));
128 long crc = crc32(0L, Z_NULL, 0);
129 unsigned char crcBuffer[16384];
131 while ((numBytes = TEMP_FAILURE_RETRY(read(fd, crcBuffer, sizeof(crcBuffer)))) > 0) {
132 crc = crc32(crc, crcBuffer, numBytes);
136 ALOGV("%s: crc = %lx, zipCrc = %lx\n", filePath, crc, zipCrc);
145 static install_status_t
146 sumFiles(JNIEnv* env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
148 size_t* total = (size_t*) arg;
151 if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, NULL, NULL)) {
152 return INSTALL_FAILED_INVALID_APK;
157 return INSTALL_SUCCEEDED;
161 * Copy the native library if needed.
163 * This function assumes the library and path names passed in are considered safe.
165 static install_status_t
166 copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
168 jstring* javaNativeLibPath = (jstring*) arg;
169 ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
176 if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, &when, &crc)) {
177 ALOGD("Couldn't read zip entry info\n");
178 return INSTALL_FAILED_INVALID_APK;
181 ZipFileRO::zipTimeToTimespec(when, &t);
182 modTime = mktime(&t);
185 // Build local file path
186 const size_t fileNameLen = strlen(fileName);
187 char localFileName[nativeLibPath.size() + fileNameLen + 2];
189 if (strlcpy(localFileName, nativeLibPath.c_str(), sizeof(localFileName)) != nativeLibPath.size()) {
190 ALOGD("Couldn't allocate local file name for library");
191 return INSTALL_FAILED_INTERNAL_ERROR;
194 *(localFileName + nativeLibPath.size()) = '/';
196 if (strlcpy(localFileName + nativeLibPath.size() + 1, fileName, sizeof(localFileName)
197 - nativeLibPath.size() - 1) != fileNameLen) {
198 ALOGD("Couldn't allocate local file name for library");
199 return INSTALL_FAILED_INTERNAL_ERROR;
202 // Only copy out the native file if it's different.
204 if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) {
205 return INSTALL_SUCCEEDED;
208 char localTmpFileName[nativeLibPath.size() + TMP_FILE_PATTERN_LEN + 2];
209 if (strlcpy(localTmpFileName, nativeLibPath.c_str(), sizeof(localTmpFileName))
210 != nativeLibPath.size()) {
211 ALOGD("Couldn't allocate local file name for library");
212 return INSTALL_FAILED_INTERNAL_ERROR;
215 *(localFileName + nativeLibPath.size()) = '/';
217 if (strlcpy(localTmpFileName + nativeLibPath.size(), TMP_FILE_PATTERN,
218 TMP_FILE_PATTERN_LEN - nativeLibPath.size()) != TMP_FILE_PATTERN_LEN) {
219 ALOGI("Couldn't allocate temporary file name for library");
220 return INSTALL_FAILED_INTERNAL_ERROR;
223 int fd = mkstemp(localTmpFileName);
225 ALOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno));
226 return INSTALL_FAILED_CONTAINER_ERROR;
229 if (!zipFile->uncompressEntry(zipEntry, fd)) {
230 ALOGI("Failed uncompressing %s to %s\n", fileName, localTmpFileName);
232 unlink(localTmpFileName);
233 return INSTALL_FAILED_CONTAINER_ERROR;
238 // Set the modification time for this file to the ZIP's mod time.
239 struct timeval times[2];
240 times[0].tv_sec = st.st_atime;
241 times[1].tv_sec = modTime;
242 times[0].tv_usec = times[1].tv_usec = 0;
243 if (utimes(localTmpFileName, times) < 0) {
244 ALOGI("Couldn't change modification time on %s: %s\n", localTmpFileName, strerror(errno));
245 unlink(localTmpFileName);
246 return INSTALL_FAILED_CONTAINER_ERROR;
249 // Set the mode to 755
250 static const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
251 if (chmod(localTmpFileName, mode) < 0) {
252 ALOGI("Couldn't change permissions on %s: %s\n", localTmpFileName, strerror(errno));
253 unlink(localTmpFileName);
254 return INSTALL_FAILED_CONTAINER_ERROR;
257 // Finally, rename it to the final name.
258 if (rename(localTmpFileName, localFileName) < 0) {
259 ALOGI("Couldn't rename %s to %s: %s\n", localTmpFileName, localFileName, strerror(errno));
260 unlink(localTmpFileName);
261 return INSTALL_FAILED_CONTAINER_ERROR;
264 ALOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName);
266 return INSTALL_SUCCEEDED;
269 static install_status_t
270 iterateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2,
271 iterFunc callFunc, void* callArg) {
272 ScopedUtfChars filePath(env, javaFilePath);
273 ScopedUtfChars cpuAbi(env, javaCpuAbi);
274 ScopedUtfChars cpuAbi2(env, javaCpuAbi2);
278 if (zipFile.open(filePath.c_str()) != NO_ERROR) {
279 ALOGI("Couldn't open APK %s\n", filePath.c_str());
280 return INSTALL_FAILED_INVALID_APK;
283 const int N = zipFile.getNumEntries();
285 char fileName[PATH_MAX];
286 bool hasPrimaryAbi = false;
288 for (int i = 0; i < N; i++) {
289 const ZipEntryRO entry = zipFile.findEntryByIndex(i);
294 // Make sure this entry has a filename.
295 if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) {
299 // Make sure we're in the lib directory of the ZIP.
300 if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) {
304 // Make sure the filename is at least to the minimum library name size.
305 const size_t fileNameLen = strlen(fileName);
306 static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN;
307 if (fileNameLen < minLength) {
311 const char* lastSlash = strrchr(fileName, '/');
312 ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName);
314 // Check to make sure the CPU ABI of this file is one we support.
315 const char* cpuAbiOffset = fileName + APK_LIB_LEN;
316 const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset;
318 ALOGV("Comparing ABIs %s and %s versus %s\n", cpuAbi.c_str(), cpuAbi2.c_str(), cpuAbiOffset);
319 if (cpuAbi.size() == cpuAbiRegionSize
320 && *(cpuAbiOffset + cpuAbi.size()) == '/'
321 && !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) {
322 ALOGV("Using primary ABI %s\n", cpuAbi.c_str());
323 hasPrimaryAbi = true;
324 } else if (cpuAbi2.size() == cpuAbiRegionSize
325 && *(cpuAbiOffset + cpuAbi2.size()) == '/'
326 && !strncmp(cpuAbiOffset, cpuAbi2.c_str(), cpuAbiRegionSize)) {
329 * If this library matches both the primary and secondary ABIs,
330 * only use the primary ABI.
333 ALOGV("Already saw primary ABI, skipping secondary ABI %s\n", cpuAbi2.c_str());
336 ALOGV("Using secondary ABI %s\n", cpuAbi2.c_str());
339 ALOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize);
343 // If this is a .so file, check to see if we need to copy it.
344 if ((!strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN)
345 && !strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN)
346 && isFilenameSafe(lastSlash + 1))
347 || !strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) {
349 install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1);
351 if (ret != INSTALL_SUCCEEDED) {
352 ALOGV("Failure for entry %s", lastSlash + 1);
358 return INSTALL_SUCCEEDED;
362 com_android_internal_content_NativeLibraryHelper_copyNativeBinaries(JNIEnv *env, jclass clazz,
363 jstring javaFilePath, jstring javaNativeLibPath, jstring javaCpuAbi, jstring javaCpuAbi2)
365 return (jint) iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2,
366 copyFileIfChanged, &javaNativeLibPath);
370 com_android_internal_content_NativeLibraryHelper_sumNativeBinaries(JNIEnv *env, jclass clazz,
371 jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2)
373 size_t totalSize = 0;
375 iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2, sumFiles, &totalSize);
380 static JNINativeMethod gMethods[] = {
381 {"nativeCopyNativeBinaries",
382 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I",
383 (void *)com_android_internal_content_NativeLibraryHelper_copyNativeBinaries},
384 {"nativeSumNativeBinaries",
385 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)J",
386 (void *)com_android_internal_content_NativeLibraryHelper_sumNativeBinaries},
390 int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env)
392 return AndroidRuntime::registerNativeMethods(env,
393 "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods));