Home | History | Annotate | Download | only in jni 
      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 <utils/Log.h>
     23 #include <utils/ZipFileRO.h>
     24 #include <ScopedUtfChars.h>
     25 
     26 #include <zlib.h>
     27 
     28 #include <fcntl.h>
     29 #include <stdlib.h>
     30 #include <string.h>
     31 #include <time.h>
     32 #include <unistd.h>
     33 #include <sys/stat.h>
     34 #include <sys/types.h>
     35 
     36 
     37 #define APK_LIB "lib/"
     38 #define APK_LIB_LEN (sizeof(APK_LIB) - 1)
     39 
     40 #define LIB_PREFIX "/lib"
     41 #define LIB_PREFIX_LEN (sizeof(LIB_PREFIX) - 1)
     42 
     43 #define LIB_SUFFIX ".so"
     44 #define LIB_SUFFIX_LEN (sizeof(LIB_SUFFIX) - 1)
     45 
     46 #define GDBSERVER "gdbserver"
     47 #define GDBSERVER_LEN (sizeof(GDBSERVER) - 1)
     48 
     49 #define TMP_FILE_PATTERN "/tmp.XXXXXX"
     50 #define TMP_FILE_PATTERN_LEN (sizeof(TMP_FILE_PATTERN) - 1)
     51 
     52 namespace android {
     53 
     54 // These match PackageManager.java install codes
     55 typedef enum {
     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,
     61 } install_status_t;
     62 
     63 typedef install_status_t (*iterFunc)(JNIEnv*, void*, ZipFileRO*, ZipEntryRO, const char*);
     64 
     65 // Equivalent to isFilenameSafe
     66 static bool
     67 isFilenameSafe(const char* filename)
     68 {
     69     off_t offset = 0;
     70     for (;;) {
     71         switch (*(filename + offset)) {
     72         case 0:
     73             // Null.
     74             // If we've reached the end, all the other characters are good.
     75             return true;
     76 
     77         case 'A' ... 'Z':
     78         case 'a' ... 'z':
     79         case '0' ... '9':
     80         case '+':
     81         case ',':
     82         case '-':
     83         case '.':
     84         case '/':
     85         case '=':
     86         case '_':
     87             offset++;
     88             break;
     89 
     90         default:
     91             // We found something that is not good.
     92             return false;
     93         }
     94     }
     95     // Should not reach here.
     96 }
     97 
     98 static bool
     99 isFileDifferent(const char* filePath, size_t fileSize, time_t modifiedTime,
    100         long zipCrc, struct stat64* st)
    101 {
    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));
    105         return true;
    106     }
    107 
    108     if (!S_ISREG(st->st_mode)) {
    109         return true;
    110     }
    111 
    112     if (st->st_size != fileSize) {
    113         return true;
    114     }
    115 
    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);
    119         return true;
    120     }
    121 
    122     int fd = TEMP_FAILURE_RETRY(open(filePath, O_RDONLY));
    123     if (fd < 0) {
    124         ALOGV("Couldn't open file %s: %s", filePath, strerror(errno));
    125         return true;
    126     }
    127 
    128     long crc = crc32(0L, Z_NULL, 0);
    129     unsigned char crcBuffer[16384];
    130     ssize_t numBytes;
    131     while ((numBytes = TEMP_FAILURE_RETRY(read(fd, crcBuffer, sizeof(crcBuffer)))) > 0) {
    132         crc = crc32(crc, crcBuffer, numBytes);
    133     }
    134     close(fd);
    135 
    136     ALOGV("%s: crc = %lx, zipCrc = %lx\n", filePath, crc, zipCrc);
    137 
    138     if (crc != zipCrc) {
    139         return true;
    140     }
    141 
    142     return false;
    143 }
    144 
    145 static install_status_t
    146 sumFiles(JNIEnv* env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
    147 {
    148     size_t* total = (size_t*) arg;
    149     size_t uncompLen;
    150 
    151     if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, NULL, NULL)) {
    152         return INSTALL_FAILED_INVALID_APK;
    153     }
    154 
    155     *total += uncompLen;
    156 
    157     return INSTALL_SUCCEEDED;
    158 }
    159 
    160 /*
    161  * Copy the native library if needed.
    162  *
    163  * This function assumes the library and path names passed in are considered safe.
    164  */
    165 static install_status_t
    166 copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
    167 {
    168     jstring* javaNativeLibPath = (jstring*) arg;
    169     ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
    170 
    171     size_t uncompLen;
    172     long when;
    173     long crc;
    174     time_t modTime;
    175 
    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;
    179     } else {
    180         struct tm t;
    181         ZipFileRO::zipTimeToTimespec(when, &t);
    182         modTime = mktime(&t);
    183     }
    184 
    185     // Build local file path
    186     const size_t fileNameLen = strlen(fileName);
    187     char localFileName[nativeLibPath.size() + fileNameLen + 2];
    188 
    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;
    192     }
    193 
    194     *(localFileName + nativeLibPath.size()) = '/';
    195 
    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;
    200     }
    201 
    202     // Only copy out the native file if it's different.
    203     struct stat st;
    204     if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) {
    205         return INSTALL_SUCCEEDED;
    206     }
    207 
    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;
    213     }
    214 
    215     *(localFileName + nativeLibPath.size()) = '/';
    216 
    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;
    221     }
    222 
    223     int fd = mkstemp(localTmpFileName);
    224     if (fd < 0) {
    225         ALOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno));
    226         return INSTALL_FAILED_CONTAINER_ERROR;
    227     }
    228 
    229     if (!zipFile->uncompressEntry(zipEntry, fd)) {
    230         ALOGI("Failed uncompressing %s to %s\n", fileName, localTmpFileName);
    231         close(fd);
    232         unlink(localTmpFileName);
    233         return INSTALL_FAILED_CONTAINER_ERROR;
    234     }
    235 
    236     close(fd);
    237 
    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;
    247     }
    248 
    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;
    255     }
    256 
    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;
    262     }
    263 
    264     ALOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName);
    265 
    266     return INSTALL_SUCCEEDED;
    267 }
    268 
    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);
    275 
    276     ZipFileRO zipFile;
    277 
    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;
    281     }
    282 
    283     const int N = zipFile.getNumEntries();
    284 
    285     char fileName[PATH_MAX];
    286     bool hasPrimaryAbi = false;
    287 
    288     for (int i = 0; i < N; i++) {
    289         const ZipEntryRO entry = zipFile.findEntryByIndex(i);
    290         if (entry == NULL) {
    291             continue;
    292         }
    293 
    294         // Make sure this entry has a filename.
    295         if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) {
    296             continue;
    297         }
    298 
    299         // Make sure we're in the lib directory of the ZIP.
    300         if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) {
    301             continue;
    302         }
    303 
    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) {
    308             continue;
    309         }
    310 
    311         const char* lastSlash = strrchr(fileName, '/');
    312         ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName);
    313 
    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;
    317 
    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)) {
    327 
    328             /*
    329              * If this library matches both the primary and secondary ABIs,
    330              * only use the primary ABI.
    331              */
    332             if (hasPrimaryAbi) {
    333                 ALOGV("Already saw primary ABI, skipping secondary ABI %s\n", cpuAbi2.c_str());
    334                 continue;
    335             } else {
    336                 ALOGV("Using secondary ABI %s\n", cpuAbi2.c_str());
    337             }
    338         } else {
    339             ALOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize);
    340             continue;
    341         }
    342 
    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)) {
    348 
    349             install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1);
    350 
    351             if (ret != INSTALL_SUCCEEDED) {
    352                 ALOGV("Failure for entry %s", lastSlash + 1);
    353                 return ret;
    354             }
    355         }
    356     }
    357 
    358     return INSTALL_SUCCEEDED;
    359 }
    360 
    361 static jint
    362 com_android_internal_content_NativeLibraryHelper_copyNativeBinaries(JNIEnv *env, jclass clazz,
    363         jstring javaFilePath, jstring javaNativeLibPath, jstring javaCpuAbi, jstring javaCpuAbi2)
    364 {
    365     return (jint) iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2,
    366             copyFileIfChanged, &javaNativeLibPath);
    367 }
    368 
    369 static jlong
    370 com_android_internal_content_NativeLibraryHelper_sumNativeBinaries(JNIEnv *env, jclass clazz,
    371         jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2)
    372 {
    373     size_t totalSize = 0;
    374 
    375     iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2, sumFiles, &totalSize);
    376 
    377     return totalSize;
    378 }
    379 
    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},
    387 };
    388 
    389 
    390 int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env)
    391 {
    392     return AndroidRuntime::registerNativeMethods(env,
    393                 "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods));
    394 }
    395 
    396 };
    397