com_android_internal_content_NativeLibraryHelper.cpp revision 1378aba7aeeb7f6dd6cc2503968ba7b0e58d9333 
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 <android_runtime/AndroidRuntime.h>
21
22#include <ScopedUtfChars.h>
23#include <UniquePtr.h>
24#include <androidfw/ZipFileRO.h>
25#include <androidfw/ZipUtils.h>
26#include <utils/Log.h>
27#include <utils/Vector.h>
28
29#include <zlib.h>
30
31#include <fcntl.h>
32#include <stdlib.h>
33#include <string.h>
34#include <time.h>
35#include <unistd.h>
36#include <sys/stat.h>
37#include <sys/types.h>
38
39
40#define APK_LIB "lib/"
41#define APK_LIB_LEN (sizeof(APK_LIB) - 1)
42
43#define LIB_PREFIX "/lib"
44#define LIB_PREFIX_LEN (sizeof(LIB_PREFIX) - 1)
45
46#define LIB_SUFFIX ".so"
47#define LIB_SUFFIX_LEN (sizeof(LIB_SUFFIX) - 1)
48
49#define GDBSERVER "gdbserver"
50#define GDBSERVER_LEN (sizeof(GDBSERVER) - 1)
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 = -112,
65    NO_NATIVE_LIBRARIES = -113
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, size_t fileSize, time_t modifiedTime,
105        long 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 (st->st_size != 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    long crc = crc32(0L, Z_NULL, 0);
134    unsigned char crcBuffer[16384];
135    ssize_t numBytes;
136    while ((numBytes = TEMP_FAILURE_RETRY(read(fd, crcBuffer, sizeof(crcBuffer)))) > 0) {
137        crc = crc32(crc, crcBuffer, numBytes);
138    }
139    close(fd);
140
141    ALOGV("%s: crc = %lx, zipCrc = %lx\n", filePath, crc, zipCrc);
142
143    if (crc != zipCrc) {
144        return true;
145    }
146
147    return false;
148}
149
150static install_status_t
151sumFiles(JNIEnv*, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char*)
152{
153    size_t* total = (size_t*) arg;
154    size_t uncompLen;
155
156    if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, NULL, NULL)) {
157        return INSTALL_FAILED_INVALID_APK;
158    }
159
160    *total += uncompLen;
161
162    return INSTALL_SUCCEEDED;
163}
164
165/*
166 * Copy the native library if needed.
167 *
168 * This function assumes the library and path names passed in are considered safe.
169 */
170static install_status_t
171copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
172{
173    jstring* javaNativeLibPath = (jstring*) arg;
174    ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
175
176    size_t uncompLen;
177    long when;
178    long crc;
179    time_t modTime;
180
181    if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, &when, &crc)) {
182        ALOGD("Couldn't read zip entry info\n");
183        return INSTALL_FAILED_INVALID_APK;
184    } else {
185        struct tm t;
186        ZipUtils::zipTimeToTimespec(when, &t);
187        modTime = mktime(&t);
188    }
189
190    // Build local file path
191    const size_t fileNameLen = strlen(fileName);
192    char localFileName[nativeLibPath.size() + fileNameLen + 2];
193
194    if (strlcpy(localFileName, nativeLibPath.c_str(), sizeof(localFileName)) != nativeLibPath.size()) {
195        ALOGD("Couldn't allocate local file name for library");
196        return INSTALL_FAILED_INTERNAL_ERROR;
197    }
198
199    *(localFileName + nativeLibPath.size()) = '/';
200
201    if (strlcpy(localFileName + nativeLibPath.size() + 1, fileName, sizeof(localFileName)
202                    - nativeLibPath.size() - 1) != fileNameLen) {
203        ALOGD("Couldn't allocate local file name for library");
204        return INSTALL_FAILED_INTERNAL_ERROR;
205    }
206
207    // Only copy out the native file if it's different.
208    struct stat64 st;
209    if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) {
210        return INSTALL_SUCCEEDED;
211    }
212
213    char localTmpFileName[nativeLibPath.size() + TMP_FILE_PATTERN_LEN + 2];
214    if (strlcpy(localTmpFileName, nativeLibPath.c_str(), sizeof(localTmpFileName))
215            != nativeLibPath.size()) {
216        ALOGD("Couldn't allocate local file name for library");
217        return INSTALL_FAILED_INTERNAL_ERROR;
218    }
219
220    *(localFileName + nativeLibPath.size()) = '/';
221
222    if (strlcpy(localTmpFileName + nativeLibPath.size(), TMP_FILE_PATTERN,
223                    TMP_FILE_PATTERN_LEN - nativeLibPath.size()) != TMP_FILE_PATTERN_LEN) {
224        ALOGI("Couldn't allocate temporary file name for library");
225        return INSTALL_FAILED_INTERNAL_ERROR;
226    }
227
228    int fd = mkstemp(localTmpFileName);
229    if (fd < 0) {
230        ALOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno));
231        return INSTALL_FAILED_CONTAINER_ERROR;
232    }
233
234    if (!zipFile->uncompressEntry(zipEntry, fd)) {
235        ALOGI("Failed uncompressing %s to %s\n", fileName, localTmpFileName);
236        close(fd);
237        unlink(localTmpFileName);
238        return INSTALL_FAILED_CONTAINER_ERROR;
239    }
240
241    close(fd);
242
243    // Set the modification time for this file to the ZIP's mod time.
244    struct timeval times[2];
245    times[0].tv_sec = st.st_atime;
246    times[1].tv_sec = modTime;
247    times[0].tv_usec = times[1].tv_usec = 0;
248    if (utimes(localTmpFileName, times) < 0) {
249        ALOGI("Couldn't change modification time on %s: %s\n", localTmpFileName, strerror(errno));
250        unlink(localTmpFileName);
251        return INSTALL_FAILED_CONTAINER_ERROR;
252    }
253
254    // Set the mode to 755
255    static const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |  S_IXGRP | S_IROTH | S_IXOTH;
256    if (chmod(localTmpFileName, mode) < 0) {
257        ALOGI("Couldn't change permissions on %s: %s\n", localTmpFileName, strerror(errno));
258        unlink(localTmpFileName);
259        return INSTALL_FAILED_CONTAINER_ERROR;
260    }
261
262    // Finally, rename it to the final name.
263    if (rename(localTmpFileName, localFileName) < 0) {
264        ALOGI("Couldn't rename %s to %s: %s\n", localTmpFileName, localFileName, strerror(errno));
265        unlink(localTmpFileName);
266        return INSTALL_FAILED_CONTAINER_ERROR;
267    }
268
269    ALOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName);
270
271    return INSTALL_SUCCEEDED;
272}
273
274/*
275 * An iterator over all shared libraries in a zip file. An entry is
276 * considered to be a shared library if all of the conditions below are
277 * satisfied :
278 *
279 * - The entry is under the lib/ directory.
280 * - The entry name ends with ".so" and the entry name starts with "lib",
281 *   an exception is made for entries whose name is "gdbserver".
282 * - The entry filename is "safe" (as determined by isFilenameSafe).
283 *
284 */
285class NativeLibrariesIterator {
286private:
287    NativeLibrariesIterator(ZipFileRO* zipFile, void* cookie)
288        : mZipFile(zipFile), mCookie(cookie), mLastSlash(NULL) {
289        fileName[0] = '\0';
290    }
291
292public:
293    static NativeLibrariesIterator* create(ZipFileRO* zipFile) {
294        void* cookie = NULL;
295        if (!zipFile->startIteration(&cookie)) {
296            return NULL;
297        }
298
299        return new NativeLibrariesIterator(zipFile, cookie);
300    }
301
302    ZipEntryRO next() {
303        ZipEntryRO next = NULL;
304        while ((next = mZipFile->nextEntry(mCookie)) != NULL) {
305            // Make sure this entry has a filename.
306            if (mZipFile->getEntryFileName(next, fileName, sizeof(fileName))) {
307                continue;
308            }
309
310            // Make sure we're in the lib directory of the ZIP.
311            if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) {
312                continue;
313            }
314
315            // Make sure the filename is at least to the minimum library name size.
316            const size_t fileNameLen = strlen(fileName);
317            static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN;
318            if (fileNameLen < minLength) {
319                continue;
320            }
321
322            const char* lastSlash = strrchr(fileName, '/');
323            ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName);
324
325            // Exception: If we find the gdbserver binary, return it.
326            if (!strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) {
327                break;
328            }
329
330            // Make sure the filename starts with lib and ends with ".so".
331            if (strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN)
332                || strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN)) {
333                continue;
334            }
335
336            // Make sure the filename is safe.
337            if (!isFilenameSafe(lastSlash + 1)) {
338                continue;
339            }
340
341            mLastSlash = lastSlash;
342            break;
343        }
344
345        return next;
346    }
347
348    inline const char* currentEntry() const {
349        return fileName;
350    }
351
352    inline const char* lastSlash() const {
353        return mLastSlash;
354    }
355
356    virtual ~NativeLibrariesIterator() {
357        mZipFile->endIteration(mCookie);
358    }
359private:
360
361    char fileName[PATH_MAX];
362    ZipFileRO* const mZipFile;
363    void* mCookie;
364    const char* mLastSlash;
365};
366
367static install_status_t
368iterateOverNativeFiles(JNIEnv *env, jlong apkHandle, jstring javaCpuAbi,
369                       iterFunc callFunc, void* callArg) {
370    ZipFileRO* zipFile = reinterpret_cast<ZipFileRO*>(apkHandle);
371    if (zipFile == NULL) {
372        return INSTALL_FAILED_INVALID_APK;
373    }
374
375    UniquePtr<NativeLibrariesIterator> it(NativeLibrariesIterator::create(zipFile));
376    if (it.get() == NULL) {
377        return INSTALL_FAILED_INVALID_APK;
378    }
379
380    const ScopedUtfChars cpuAbi(env, javaCpuAbi);
381    if (cpuAbi.c_str() == NULL) {
382        // This would've thrown, so this return code isn't observable by
383        // Java.
384        return INSTALL_FAILED_INVALID_APK;
385    }
386    ZipEntryRO entry = NULL;
387    while ((entry = it->next()) != NULL) {
388        const char* fileName = it->currentEntry();
389        const char* lastSlash = it->lastSlash();
390
391        // Check to make sure the CPU ABI of this file is one we support.
392        const char* cpuAbiOffset = fileName + APK_LIB_LEN;
393        const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset;
394
395        if (cpuAbi.size() == cpuAbiRegionSize && !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) {
396            install_status_t ret = callFunc(env, callArg, zipFile, entry, lastSlash + 1);
397
398            if (ret != INSTALL_SUCCEEDED) {
399                ALOGV("Failure for entry %s", lastSlash + 1);
400                return ret;
401            }
402        }
403    }
404
405    return INSTALL_SUCCEEDED;
406}
407
408
409static int findSupportedAbi(JNIEnv *env, jlong apkHandle, jobjectArray supportedAbisArray) {
410    const int numAbis = env->GetArrayLength(supportedAbisArray);
411    Vector<ScopedUtfChars*> supportedAbis;
412
413    for (int i = 0; i < numAbis; ++i) {
414        supportedAbis.add(new ScopedUtfChars(env,
415            (jstring) env->GetObjectArrayElement(supportedAbisArray, i)));
416    }
417
418    ZipFileRO* zipFile = reinterpret_cast<ZipFileRO*>(apkHandle);
419    if (zipFile == NULL) {
420        return INSTALL_FAILED_INVALID_APK;
421    }
422
423    UniquePtr<NativeLibrariesIterator> it(NativeLibrariesIterator::create(zipFile));
424    if (it.get() == NULL) {
425        return INSTALL_FAILED_INVALID_APK;
426    }
427
428    ZipEntryRO entry = NULL;
429    char fileName[PATH_MAX];
430    int status = NO_NATIVE_LIBRARIES;
431    while ((entry = it->next()) != NULL) {
432        // We're currently in the lib/ directory of the APK, so it does have some native
433        // code. We should return INSTALL_FAILED_NO_MATCHING_ABIS if none of the
434        // libraries match.
435        if (status == NO_NATIVE_LIBRARIES) {
436            status = INSTALL_FAILED_NO_MATCHING_ABIS;
437        }
438
439        const char* fileName = it->currentEntry();
440        const char* lastSlash = it->lastSlash();
441
442        // Check to see if this CPU ABI matches what we are looking for.
443        const char* abiOffset = fileName + APK_LIB_LEN;
444        const size_t abiSize = lastSlash - abiOffset;
445        for (int i = 0; i < numAbis; i++) {
446            const ScopedUtfChars* abi = supportedAbis[i];
447            if (abi->size() == abiSize && !strncmp(abiOffset, abi->c_str(), abiSize)) {
448                // The entry that comes in first (i.e. with a lower index) has the higher priority.
449                if (((i < status) && (status >= 0)) || (status < 0) ) {
450                    status = i;
451                }
452            }
453        }
454    }
455
456    for (int i = 0; i < numAbis; ++i) {
457        delete supportedAbis[i];
458    }
459
460    return status;
461}
462
463static jint
464com_android_internal_content_NativeLibraryHelper_copyNativeBinaries(JNIEnv *env, jclass clazz,
465        jlong apkHandle, jstring javaNativeLibPath, jstring javaCpuAbi)
466{
467    return (jint) iterateOverNativeFiles(env, apkHandle, javaCpuAbi,
468            copyFileIfChanged, &javaNativeLibPath);
469}
470
471static jlong
472com_android_internal_content_NativeLibraryHelper_sumNativeBinaries(JNIEnv *env, jclass clazz,
473        jlong apkHandle, jstring javaCpuAbi)
474{
475    size_t totalSize = 0;
476
477    iterateOverNativeFiles(env, apkHandle, javaCpuAbi, sumFiles, &totalSize);
478
479    return totalSize;
480}
481
482static jint
483com_android_internal_content_NativeLibraryHelper_findSupportedAbi(JNIEnv *env, jclass clazz,
484        jlong apkHandle, jobjectArray javaCpuAbisToSearch)
485{
486    return (jint) findSupportedAbi(env, apkHandle, javaCpuAbisToSearch);
487}
488
489static jlong
490com_android_internal_content_NativeLibraryHelper_openApk(JNIEnv *env, jclass, jstring apkPath)
491{
492    ScopedUtfChars filePath(env, apkPath);
493    ZipFileRO* zipFile = ZipFileRO::open(filePath.c_str());
494
495    return reinterpret_cast<jlong>(zipFile);
496}
497
498static void
499com_android_internal_content_NativeLibraryHelper_close(JNIEnv *env, jclass, jlong apkHandle)
500{
501    delete reinterpret_cast<ZipFileRO*>(apkHandle);
502}
503
504static JNINativeMethod gMethods[] = {
505    {"nativeOpenApk",
506            "(Ljava/lang/String;)J",
507            (void *)com_android_internal_content_NativeLibraryHelper_openApk},
508    {"nativeClose",
509            "(J)V",
510            (void *)com_android_internal_content_NativeLibraryHelper_close},
511    {"nativeCopyNativeBinaries",
512            "(JLjava/lang/String;Ljava/lang/String;)I",
513            (void *)com_android_internal_content_NativeLibraryHelper_copyNativeBinaries},
514    {"nativeSumNativeBinaries",
515            "(JLjava/lang/String;)J",
516            (void *)com_android_internal_content_NativeLibraryHelper_sumNativeBinaries},
517    {"nativeFindSupportedAbi",
518            "(J[Ljava/lang/String;)I",
519            (void *)com_android_internal_content_NativeLibraryHelper_findSupportedAbi},
520};
521
522
523int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env)
524{
525    return AndroidRuntime::registerNativeMethods(env,
526                "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods));
527}
528
529};
530