com_android_internal_content_NativeLibraryHelper.cpp revision d6dd6b8a613c9c91eeebde713f12f18e6cc43c1f 
1/*
2 * Copyright (C) 2011 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#define LOG_TAG "NativeLibraryHelper"
18//#define LOG_NDEBUG 0
19
20#include "core_jni_helpers.h"
21
22#include <ScopedUtfChars.h>
23#include <androidfw/ZipFileRO.h>
24#include <androidfw/ZipUtils.h>
25#include <utils/Log.h>
26#include <utils/Vector.h>
27
28#include <zlib.h>
29
30#include <fcntl.h>
31#include <stdlib.h>
32#include <string.h>
33#include <time.h>
34#include <unistd.h>
35#include <inttypes.h>
36#include <sys/stat.h>
37#include <sys/types.h>
38
39#include <memory>
40
41#define APK_LIB "lib/"
42#define APK_LIB_LEN (sizeof(APK_LIB) - 1)
43
44#define LIB_PREFIX "/lib"
45#define LIB_PREFIX_LEN (sizeof(LIB_PREFIX) - 1)
46
47#define LIB_SUFFIX ".so"
48#define LIB_SUFFIX_LEN (sizeof(LIB_SUFFIX) - 1)
49
50#define RS_BITCODE_SUFFIX ".bc"
51
52#define TMP_FILE_PATTERN "/tmp.XXXXXX"
53#define TMP_FILE_PATTERN_LEN (sizeof(TMP_FILE_PATTERN) - 1)
54
55namespace android {
56
57// These match PackageManager.java install codes
58enum install_status_t {
59    INSTALL_SUCCEEDED = 1,
60    INSTALL_FAILED_INVALID_APK = -2,
61    INSTALL_FAILED_INSUFFICIENT_STORAGE = -4,
62    INSTALL_FAILED_CONTAINER_ERROR = -18,
63    INSTALL_FAILED_INTERNAL_ERROR = -110,
64    INSTALL_FAILED_NO_MATCHING_ABIS = -113,
65    NO_NATIVE_LIBRARIES = -114
66};
67
68typedef install_status_t (*iterFunc)(JNIEnv*, void*, ZipFileRO*, ZipEntryRO, const char*);
69
70// Equivalent to android.os.FileUtils.isFilenameSafe
71static bool
72isFilenameSafe(const char* filename)
73{
74    off_t offset = 0;
75    for (;;) {
76        switch (*(filename + offset)) {
77        case 0:
78            // Null.
79            // If we've reached the end, all the other characters are good.
80            return true;
81
82        case 'A' ... 'Z':
83        case 'a' ... 'z':
84        case '0' ... '9':
85        case '+':
86        case ',':
87        case '-':
88        case '.':
89        case '/':
90        case '=':
91        case '_':
92            offset++;
93            break;
94
95        default:
96            // We found something that is not good.
97            return false;
98        }
99    }
100    // Should not reach here.
101}
102
103static bool
104isFileDifferent(const char* filePath, uint32_t fileSize, time_t modifiedTime,
105        uint32_t zipCrc, struct stat64* st)
106{
107    if (lstat64(filePath, st) < 0) {
108        // File is not found or cannot be read.
109        ALOGV("Couldn't stat %s, copying: %s\n", filePath, strerror(errno));
110        return true;
111    }
112
113    if (!S_ISREG(st->st_mode)) {
114        return true;
115    }
116
117    if (static_cast<uint64_t>(st->st_size) != static_cast<uint64_t>(fileSize)) {
118        return true;
119    }
120
121    // For some reason, bionic doesn't define st_mtime as time_t
122    if (time_t(st->st_mtime) != modifiedTime) {
123        ALOGV("mod time doesn't match: %ld vs. %ld\n", st->st_mtime, modifiedTime);
124        return true;
125    }
126
127    int fd = TEMP_FAILURE_RETRY(open(filePath, O_RDONLY));
128    if (fd < 0) {
129        ALOGV("Couldn't open file %s: %s", filePath, strerror(errno));
130        return true;
131    }
132
133    // uLong comes from zlib.h. It's a bit of a wart that they're
134    // potentially using a 64-bit type for a 32-bit CRC.
135    uLong crc = crc32(0L, Z_NULL, 0);
136    unsigned char crcBuffer[16384];
137    ssize_t numBytes;
138    while ((numBytes = TEMP_FAILURE_RETRY(read(fd, crcBuffer, sizeof(crcBuffer)))) > 0) {
139        crc = crc32(crc, crcBuffer, numBytes);
140    }
141    close(fd);
142
143    ALOGV("%s: crc = %lx, zipCrc = %" PRIu32 "\n", filePath, crc, zipCrc);
144
145    if (crc != static_cast<uLong>(zipCrc)) {
146        return true;
147    }
148
149    return false;
150}
151
152static install_status_t
153sumFiles(JNIEnv*, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char*)
154{
155    size_t* total = (size_t*) arg;
156    uint32_t uncompLen;
157
158    if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, NULL, NULL)) {
159        return INSTALL_FAILED_INVALID_APK;
160    }
161
162    *total += static_cast<size_t>(uncompLen);
163
164    return INSTALL_SUCCEEDED;
165}
166
167/*
168 * Copy the native library if needed.
169 *
170 * This function assumes the library and path names passed in are considered safe.
171 */
172static install_status_t
173copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
174{
175    void** args = reinterpret_cast<void**>(arg);
176    jstring* javaNativeLibPath = (jstring*) args[0];
177    jboolean extractNativeLibs = *(jboolean*) args[1];
178    jboolean hasNativeBridge = *(jboolean*) args[2];
179
180    ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
181
182    uint32_t uncompLen;
183    uint32_t when;
184    uint32_t crc;
185
186    uint16_t method;
187    off64_t offset;
188
189    if (!zipFile->getEntryInfo(zipEntry, &method, &uncompLen, NULL, &offset, &when, &crc)) {
190        ALOGD("Couldn't read zip entry info\n");
191        return INSTALL_FAILED_INVALID_APK;
192    }
193
194    if (!extractNativeLibs) {
195        // check if library is uncompressed and page-aligned
196        if (method != ZipFileRO::kCompressStored) {
197            ALOGD("Library '%s' is compressed - will not be able to open it directly from apk.\n",
198                fileName);
199            return INSTALL_FAILED_INVALID_APK;
200        }
201
202        if (offset % PAGE_SIZE != 0) {
203            ALOGD("Library '%s' is not page-aligned - will not be able to open it directly from"
204                " apk.\n", fileName);
205            return INSTALL_FAILED_INVALID_APK;
206        }
207
208        if (!hasNativeBridge) {
209          return INSTALL_SUCCEEDED;
210        }
211    }
212
213    // Build local file path
214    const size_t fileNameLen = strlen(fileName);
215    char localFileName[nativeLibPath.size() + fileNameLen + 2];
216
217    if (strlcpy(localFileName, nativeLibPath.c_str(), sizeof(localFileName)) != nativeLibPath.size()) {
218        ALOGD("Couldn't allocate local file name for library");
219        return INSTALL_FAILED_INTERNAL_ERROR;
220    }
221
222    *(localFileName + nativeLibPath.size()) = '/';
223
224    if (strlcpy(localFileName + nativeLibPath.size() + 1, fileName, sizeof(localFileName)
225                    - nativeLibPath.size() - 1) != fileNameLen) {
226        ALOGD("Couldn't allocate local file name for library");
227        return INSTALL_FAILED_INTERNAL_ERROR;
228    }
229
230    // Only copy out the native file if it's different.
231    struct tm t;
232    ZipUtils::zipTimeToTimespec(when, &t);
233    const time_t modTime = mktime(&t);
234    struct stat64 st;
235    if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) {
236        return INSTALL_SUCCEEDED;
237    }
238
239    char localTmpFileName[nativeLibPath.size() + TMP_FILE_PATTERN_LEN + 2];
240    if (strlcpy(localTmpFileName, nativeLibPath.c_str(), sizeof(localTmpFileName))
241            != nativeLibPath.size()) {
242        ALOGD("Couldn't allocate local file name for library");
243        return INSTALL_FAILED_INTERNAL_ERROR;
244    }
245
246    *(localFileName + nativeLibPath.size()) = '/';
247
248    if (strlcpy(localTmpFileName + nativeLibPath.size(), TMP_FILE_PATTERN,
249                    TMP_FILE_PATTERN_LEN - nativeLibPath.size()) != TMP_FILE_PATTERN_LEN) {
250        ALOGI("Couldn't allocate temporary file name for library");
251        return INSTALL_FAILED_INTERNAL_ERROR;
252    }
253
254    int fd = mkstemp(localTmpFileName);
255    if (fd < 0) {
256        ALOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno));
257        return INSTALL_FAILED_CONTAINER_ERROR;
258    }
259
260    if (!zipFile->uncompressEntry(zipEntry, fd)) {
261        ALOGI("Failed uncompressing %s to %s\n", fileName, localTmpFileName);
262        close(fd);
263        unlink(localTmpFileName);
264        return INSTALL_FAILED_CONTAINER_ERROR;
265    }
266
267    close(fd);
268
269    // Set the modification time for this file to the ZIP's mod time.
270    struct timeval times[2];
271    times[0].tv_sec = st.st_atime;
272    times[1].tv_sec = modTime;
273    times[0].tv_usec = times[1].tv_usec = 0;
274    if (utimes(localTmpFileName, times) < 0) {
275        ALOGI("Couldn't change modification time on %s: %s\n", localTmpFileName, strerror(errno));
276        unlink(localTmpFileName);
277        return INSTALL_FAILED_CONTAINER_ERROR;
278    }
279
280    // Set the mode to 755
281    static const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |  S_IXGRP | S_IROTH | S_IXOTH;
282    if (chmod(localTmpFileName, mode) < 0) {
283        ALOGI("Couldn't change permissions on %s: %s\n", localTmpFileName, strerror(errno));
284        unlink(localTmpFileName);
285        return INSTALL_FAILED_CONTAINER_ERROR;
286    }
287
288    // Finally, rename it to the final name.
289    if (rename(localTmpFileName, localFileName) < 0) {
290        ALOGI("Couldn't rename %s to %s: %s\n", localTmpFileName, localFileName, strerror(errno));
291        unlink(localTmpFileName);
292        return INSTALL_FAILED_CONTAINER_ERROR;
293    }
294
295    ALOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName);
296
297    return INSTALL_SUCCEEDED;
298}
299
300/*
301 * An iterator over all shared libraries in a zip file. An entry is
302 * considered to be a shared library if all of the conditions below are
303 * satisfied :
304 *
305 * - The entry is under the lib/ directory.
306 * - The entry name ends with ".so" and the entry name starts with "lib",
307 *   an exception is made for entries whose name is "gdbserver".
308 * - The entry filename is "safe" (as determined by isFilenameSafe).
309 *
310 */
311class NativeLibrariesIterator {
312private:
313    NativeLibrariesIterator(ZipFileRO* zipFile, bool debuggable, void* cookie)
314        : mZipFile(zipFile), mDebuggable(debuggable), mCookie(cookie), mLastSlash(NULL) {
315        fileName[0] = '\0';
316    }
317
318public:
319    static NativeLibrariesIterator* create(ZipFileRO* zipFile, bool debuggable) {
320        void* cookie = NULL;
321        // Do not specify a suffix to find both .so files and gdbserver.
322        if (!zipFile->startIteration(&cookie, APK_LIB, NULL /* suffix */)) {
323            return NULL;
324        }
325
326        return new NativeLibrariesIterator(zipFile, debuggable, cookie);
327    }
328
329    ZipEntryRO next() {
330        ZipEntryRO next = NULL;
331        while ((next = mZipFile->nextEntry(mCookie)) != NULL) {
332            // Make sure this entry has a filename.
333            if (mZipFile->getEntryFileName(next, fileName, sizeof(fileName))) {
334                continue;
335            }
336
337            // Make sure the filename is at least to the minimum library name size.
338            const size_t fileNameLen = strlen(fileName);
339            static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN;
340            if (fileNameLen < minLength) {
341                continue;
342            }
343
344            const char* lastSlash = strrchr(fileName, '/');
345            ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName);
346
347            // Make sure the filename is safe.
348            if (!isFilenameSafe(lastSlash + 1)) {
349                continue;
350            }
351
352            if (!mDebuggable) {
353              // Make sure the filename starts with lib and ends with ".so".
354              if (strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN)
355                  || strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN)) {
356                  continue;
357              }
358            }
359
360            mLastSlash = lastSlash;
361            break;
362        }
363
364        return next;
365    }
366
367    inline const char* currentEntry() const {
368        return fileName;
369    }
370
371    inline const char* lastSlash() const {
372        return mLastSlash;
373    }
374
375    virtual ~NativeLibrariesIterator() {
376        mZipFile->endIteration(mCookie);
377    }
378private:
379
380    char fileName[PATH_MAX];
381    ZipFileRO* const mZipFile;
382    const bool mDebuggable;
383    void* mCookie;
384    const char* mLastSlash;
385};
386
387static install_status_t
388iterateOverNativeFiles(JNIEnv *env, jlong apkHandle, jstring javaCpuAbi,
389                       jboolean debuggable, iterFunc callFunc, void* callArg) {
390    ZipFileRO* zipFile = reinterpret_cast<ZipFileRO*>(apkHandle);
391    if (zipFile == NULL) {
392        return INSTALL_FAILED_INVALID_APK;
393    }
394
395    std::unique_ptr<NativeLibrariesIterator> it(
396            NativeLibrariesIterator::create(zipFile, debuggable));
397    if (it.get() == NULL) {
398        return INSTALL_FAILED_INVALID_APK;
399    }
400
401    const ScopedUtfChars cpuAbi(env, javaCpuAbi);
402    if (cpuAbi.c_str() == NULL) {
403        // This would've thrown, so this return code isn't observable by
404        // Java.
405        return INSTALL_FAILED_INVALID_APK;
406    }
407    ZipEntryRO entry = NULL;
408    while ((entry = it->next()) != NULL) {
409        const char* fileName = it->currentEntry();
410        const char* lastSlash = it->lastSlash();
411
412        // Check to make sure the CPU ABI of this file is one we support.
413        const char* cpuAbiOffset = fileName + APK_LIB_LEN;
414        const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset;
415
416        if (cpuAbi.size() == cpuAbiRegionSize && !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) {
417            install_status_t ret = callFunc(env, callArg, zipFile, entry, lastSlash + 1);
418
419            if (ret != INSTALL_SUCCEEDED) {
420                ALOGV("Failure for entry %s", lastSlash + 1);
421                return ret;
422            }
423        }
424    }
425
426    return INSTALL_SUCCEEDED;
427}
428
429
430static int findSupportedAbi(JNIEnv *env, jlong apkHandle, jobjectArray supportedAbisArray,
431        jboolean debuggable) {
432    const int numAbis = env->GetArrayLength(supportedAbisArray);
433    Vector<ScopedUtfChars*> supportedAbis;
434
435    for (int i = 0; i < numAbis; ++i) {
436        supportedAbis.add(new ScopedUtfChars(env,
437            (jstring) env->GetObjectArrayElement(supportedAbisArray, i)));
438    }
439
440    ZipFileRO* zipFile = reinterpret_cast<ZipFileRO*>(apkHandle);
441    if (zipFile == NULL) {
442        return INSTALL_FAILED_INVALID_APK;
443    }
444
445    std::unique_ptr<NativeLibrariesIterator> it(
446            NativeLibrariesIterator::create(zipFile, debuggable));
447    if (it.get() == NULL) {
448        return INSTALL_FAILED_INVALID_APK;
449    }
450
451    ZipEntryRO entry = NULL;
452    int status = NO_NATIVE_LIBRARIES;
453    while ((entry = it->next()) != NULL) {
454        // We're currently in the lib/ directory of the APK, so it does have some native
455        // code. We should return INSTALL_FAILED_NO_MATCHING_ABIS if none of the
456        // libraries match.
457        if (status == NO_NATIVE_LIBRARIES) {
458            status = INSTALL_FAILED_NO_MATCHING_ABIS;
459        }
460
461        const char* fileName = it->currentEntry();
462        const char* lastSlash = it->lastSlash();
463
464        // Check to see if this CPU ABI matches what we are looking for.
465        const char* abiOffset = fileName + APK_LIB_LEN;
466        const size_t abiSize = lastSlash - abiOffset;
467        for (int i = 0; i < numAbis; i++) {
468            const ScopedUtfChars* abi = supportedAbis[i];
469            if (abi->size() == abiSize && !strncmp(abiOffset, abi->c_str(), abiSize)) {
470                // The entry that comes in first (i.e. with a lower index) has the higher priority.
471                if (((i < status) && (status >= 0)) || (status < 0) ) {
472                    status = i;
473                }
474            }
475        }
476    }
477
478    for (int i = 0; i < numAbis; ++i) {
479        delete supportedAbis[i];
480    }
481
482    return status;
483}
484
485static jint
486com_android_internal_content_NativeLibraryHelper_copyNativeBinaries(JNIEnv *env, jclass clazz,
487        jlong apkHandle, jstring javaNativeLibPath, jstring javaCpuAbi,
488        jboolean extractNativeLibs, jboolean hasNativeBridge, jboolean debuggable)
489{
490    void* args[] = { &javaNativeLibPath, &extractNativeLibs, &hasNativeBridge };
491    return (jint) iterateOverNativeFiles(env, apkHandle, javaCpuAbi, debuggable,
492            copyFileIfChanged, reinterpret_cast<void*>(args));
493}
494
495static jlong
496com_android_internal_content_NativeLibraryHelper_sumNativeBinaries(JNIEnv *env, jclass clazz,
497        jlong apkHandle, jstring javaCpuAbi, jboolean debuggable)
498{
499    size_t totalSize = 0;
500
501    iterateOverNativeFiles(env, apkHandle, javaCpuAbi, debuggable, sumFiles, &totalSize);
502
503    return totalSize;
504}
505
506static jint
507com_android_internal_content_NativeLibraryHelper_findSupportedAbi(JNIEnv *env, jclass clazz,
508        jlong apkHandle, jobjectArray javaCpuAbisToSearch, jboolean debuggable)
509{
510    return (jint) findSupportedAbi(env, apkHandle, javaCpuAbisToSearch, debuggable);
511}
512
513enum bitcode_scan_result_t {
514  APK_SCAN_ERROR = -1,
515  NO_BITCODE_PRESENT = 0,
516  BITCODE_PRESENT = 1,
517};
518
519static jint
520com_android_internal_content_NativeLibraryHelper_hasRenderscriptBitcode(JNIEnv *env, jclass clazz,
521        jlong apkHandle) {
522    ZipFileRO* zipFile = reinterpret_cast<ZipFileRO*>(apkHandle);
523    void* cookie = NULL;
524    if (!zipFile->startIteration(&cookie, NULL /* prefix */, RS_BITCODE_SUFFIX)) {
525        return APK_SCAN_ERROR;
526    }
527
528    char fileName[PATH_MAX];
529    ZipEntryRO next = NULL;
530    while ((next = zipFile->nextEntry(cookie)) != NULL) {
531        if (zipFile->getEntryFileName(next, fileName, sizeof(fileName))) {
532            continue;
533        }
534        const char* lastSlash = strrchr(fileName, '/');
535        const char* baseName = (lastSlash == NULL) ? fileName : fileName + 1;
536        if (isFilenameSafe(baseName)) {
537            zipFile->endIteration(cookie);
538            return BITCODE_PRESENT;
539        }
540    }
541
542    zipFile->endIteration(cookie);
543    return NO_BITCODE_PRESENT;
544}
545
546static jlong
547com_android_internal_content_NativeLibraryHelper_openApk(JNIEnv *env, jclass, jstring apkPath)
548{
549    ScopedUtfChars filePath(env, apkPath);
550    ZipFileRO* zipFile = ZipFileRO::open(filePath.c_str());
551
552    return reinterpret_cast<jlong>(zipFile);
553}
554
555static void
556com_android_internal_content_NativeLibraryHelper_close(JNIEnv *env, jclass, jlong apkHandle)
557{
558    delete reinterpret_cast<ZipFileRO*>(apkHandle);
559}
560
561static const JNINativeMethod gMethods[] = {
562    {"nativeOpenApk",
563            "(Ljava/lang/String;)J",
564            (void *)com_android_internal_content_NativeLibraryHelper_openApk},
565    {"nativeClose",
566            "(J)V",
567            (void *)com_android_internal_content_NativeLibraryHelper_close},
568    {"nativeCopyNativeBinaries",
569            "(JLjava/lang/String;Ljava/lang/String;ZZZ)I",
570            (void *)com_android_internal_content_NativeLibraryHelper_copyNativeBinaries},
571    {"nativeSumNativeBinaries",
572            "(JLjava/lang/String;Z)J",
573            (void *)com_android_internal_content_NativeLibraryHelper_sumNativeBinaries},
574    {"nativeFindSupportedAbi",
575            "(J[Ljava/lang/String;Z)I",
576            (void *)com_android_internal_content_NativeLibraryHelper_findSupportedAbi},
577    {"hasRenderscriptBitcode", "(J)I",
578            (void *)com_android_internal_content_NativeLibraryHelper_hasRenderscriptBitcode},
579};
580
581
582int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env)
583{
584    return RegisterMethodsOrDie(env,
585            "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods));
586}
587
588};
589