vm/JarFile.cpp

   1 /*
   2  * Copyright (C) 2008 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 /*
  18  * Access the contents of a Jar file.
  19  *
  20  * This isn't actually concerned with any of the Jar-like elements; it
  21  * just wants a zip archive with "classes.dex" inside.  In Android the
  22  * most common example is ".apk".
  23  */
  24
  25 #include "Dalvik.h"
  26 #include "libdex/OptInvocation.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <zlib.h>
  31 #include <fcntl.h>
  32 #include <errno.h>
  33
  34 static const char* kDexInJarName = "classes.dex";
  35
  36 /*
  37  * Attempt to open a file whose name is similar to <fileName>,
  38  * but with the supplied suffix.  E.g.,
  39  * openAlternateSuffix("Home.apk", "dex", O_RDONLY) will attempt
  40  * to open "Home.dex".  If the open succeeds, a pointer to a
  41  * malloc()ed copy of the opened file name will be put in <*pCachedName>.
  42  *
  43  * <flags> is passed directly to open(). O_CREAT is not supported.
  44  */
  45 static int openAlternateSuffix(const char *fileName, const char *suffix,
  46     int flags, char **pCachedName)
  47 {
  48     char *buf, *c;
  49     size_t fileNameLen = strlen(fileName);
  50     size_t suffixLen = strlen(suffix);
  51     size_t bufLen = fileNameLen + suffixLen + 1;
  52     int fd = -1;
  53
  54     buf = (char*)malloc(bufLen);
  55     if (buf == NULL) {
  56         errno = ENOMEM;
  57         return -1;
  58     }
  59
  60     /* Copy the original filename into the buffer, find
  61      * the last dot, and copy the suffix to just after it.
  62      */
  63     memcpy(buf, fileName, fileNameLen + 1);
  64     c = strrchr(buf, '.');
  65     if (c == NULL) {
  66         errno = ENOENT;
  67         goto bail;
  68     }
  69     memcpy(c + 1, suffix, suffixLen + 1);
  70
  71     fd = open(buf, flags);
  72     if (fd >= 0) {
  73         *pCachedName = buf;
  74         return fd;
  75     }
  76     ALOGV("Couldn't open %s: %s", buf, strerror(errno));
  77 bail:
  78     free(buf);
  79     return -1;
  80 }
  81
  82 /*
  83  * Checks the dependencies of the dex cache file corresponding
  84  * to the jar file at the absolute path "fileName".
  85  */
  86 DexCacheStatus dvmDexCacheStatus(const char *fileName)
  87 {
  88     ZipArchive archive;
  89     char* cachedName = NULL;
  90     int fd;
  91     DexCacheStatus result = DEX_CACHE_ERROR;
  92     ZipEntry entry;
  93
  94     /* Always treat elements of the bootclasspath as up-to-date.
  95      * The fact that interpreted code is running at all means that this
  96      * should be true.
  97      */
  98     if (dvmClassPathContains(gDvm.bootClassPath, fileName)) {
  99         return DEX_CACHE_OK;
 100     }
 101
 102     //TODO: match dvmJarFileOpen()'s logic.  Not super-important
 103     //      (the odex-first logic is only necessary for dexpreopt)
 104     //      but it would be nice to be consistent.
 105
 106     /* Try to find the dex file inside of the archive.
 107      */
 108     if (dexZipOpenArchive(fileName, &archive) != 0) {
 109         return DEX_CACHE_BAD_ARCHIVE;
 110     }
 111     entry = dexZipFindEntry(&archive, kDexInJarName);
 112     if (entry != NULL) {
 113         bool newFile = false;
 114
 115         /*
 116          * See if there's an up-to-date copy of the optimized dex
 117          * in the cache, but don't create one if there isn't.
 118          */
 119         ALOGV("dvmDexCacheStatus: Checking cache for %s", fileName);
 120         cachedName = dexOptGenerateCacheFileName(fileName, kDexInJarName);
 121         if (cachedName == NULL)
 122             return DEX_CACHE_BAD_ARCHIVE;
 123
 124         fd = dvmOpenCachedDexFile(fileName, cachedName,
 125                 dexGetZipEntryModTime(&archive, entry),
 126                 dexGetZipEntryCrc32(&archive, entry),
 127                 /*isBootstrap=*/false, &newFile, /*createIfMissing=*/false);
 128         ALOGV("dvmOpenCachedDexFile returned fd %d", fd);
 129         if (fd < 0) {
 130             result = DEX_CACHE_STALE;
 131             goto bail;
 132         }
 133
 134         /* dvmOpenCachedDexFile locks the file as a side-effect.
 135          * Unlock and close it.
 136          */
 137         if (!dvmUnlockCachedDexFile(fd)) {
 138             /* uh oh -- this process needs to exit or we'll wedge the system */
 139             ALOGE("Unable to unlock DEX file");
 140             goto bail;
 141         }
 142
 143         /* When createIfMissing is false, dvmOpenCachedDexFile() only
 144          * returns a valid fd if the cache file is up-to-date.
 145          */
 146     } else {
 147         /*
 148          * There's no dex file in the jar file.  See if there's an
 149          * optimized dex file living alongside the jar.
 150          */
 151         fd = openAlternateSuffix(fileName, "odex", O_RDONLY, &cachedName);
 152         if (fd < 0) {
 153             ALOGI("Zip is good, but no %s inside, and no .odex "
 154                     "file in the same directory", kDexInJarName);
 155             result = DEX_CACHE_BAD_ARCHIVE;
 156             goto bail;
 157         }
 158
 159         ALOGV("Using alternate file (odex) for %s ...", fileName);
 160         if (!dvmCheckOptHeaderAndDependencies(fd, false, 0, 0, true, true)) {
 161             ALOGE("%s odex has stale dependencies", fileName);
 162             ALOGE("odex source not available -- failing");
 163             result = DEX_CACHE_STALE_ODEX;
 164             goto bail;
 165         } else {
 166             ALOGV("%s odex has good dependencies", fileName);
 167         }
 168     }
 169     result = DEX_CACHE_OK;
 170
 171 bail:
 172     dexZipCloseArchive(&archive);
 173     free(cachedName);
 174     if (fd >= 0) {
 175         close(fd);
 176     }
 177     return result;
 178 }
 179
 180 /*
 181  * Open a Jar file.  It's okay if it's just a Zip archive without all of
 182  * the Jar trimmings, but we do insist on finding "classes.dex" inside
 183  * or an appropriately-named ".odex" file alongside.
 184  *
 185  * If "isBootstrap" is not set, the optimizer/verifier regards this DEX as
 186  * being part of a different class loader.
 187  */
 188 int dvmJarFileOpen(const char* fileName, const char* odexOutputName,
 189     JarFile** ppJarFile, bool isBootstrap)
 190 {
 191     /*
 192      * TODO: This function has been duplicated and modified to become
 193      * dvmRawDexFileOpen() in RawDexFile.c. This should be refactored.
 194      */
 195
 196     ZipArchive archive;
 197     DvmDex* pDvmDex = NULL;
 198     char* cachedName = NULL;
 199     bool archiveOpen = false;
 200     bool locked = false;
 201     int fd = -1;
 202     int result = -1;
 203
 204     /* Even if we're not going to look at the archive, we need to
 205      * open it so we can stuff it into ppJarFile.
 206      */
 207     if (dexZipOpenArchive(fileName, &archive) != 0)
 208         goto bail;
 209     archiveOpen = true;
 210
 211     /* If we fork/exec into dexopt, don't let it inherit the archive's fd.
 212      */
 213     dvmSetCloseOnExec(dexZipGetArchiveFd(&archive));
 214
 215     /* First, look for a ".odex" alongside the jar file.  It will
 216      * have the same name/path except for the extension.
 217      */
 218     fd = openAlternateSuffix(fileName, "odex", O_RDONLY, &cachedName);
 219     if (fd >= 0) {
 220         ALOGV("Using alternate file (odex) for %s ...", fileName);
 221         if (!dvmCheckOptHeaderAndDependencies(fd, false, 0, 0, true, true)) {
 222             ALOGE("%s odex has stale dependencies", fileName);
 223             free(cachedName);
 224             cachedName = NULL;
 225             close(fd);
 226             fd = -1;
 227             goto tryArchive;
 228         } else {
 229             ALOGV("%s odex has good dependencies", fileName);
 230             //TODO: make sure that the .odex actually corresponds
 231             //      to the classes.dex inside the archive (if present).
 232             //      For typical use there will be no classes.dex.
 233         }
 234     } else {
 235         ZipEntry entry;
 236
 237 tryArchive:
 238         /*
 239          * Pre-created .odex absent or stale.  Look inside the jar for a
 240          * "classes.dex".
 241          */
 242         entry = dexZipFindEntry(&archive, kDexInJarName);
 243         if (entry != NULL) {
 244             bool newFile = false;
 245
 246             /*
 247              * We've found the one we want.  See if there's an up-to-date copy
 248              * in the cache.
 249              *
 250              * On return, "fd" will be seeked just past the "opt" header.
 251              *
 252              * If a stale .odex file is present and classes.dex exists in
 253              * the archive, this will *not* return an fd pointing to the
 254              * .odex file; the fd will point into dalvik-cache like any
 255              * other jar.
 256              */
 257             if (odexOutputName == NULL) {
 258                 cachedName = dexOptGenerateCacheFileName(fileName,
 259                                 kDexInJarName);
 260                 if (cachedName == NULL)
 261                     goto bail;
 262             } else {
 263                 cachedName = strdup(odexOutputName);
 264             }
 265             ALOGV("dvmJarFileOpen: Checking cache for %s (%s)",
 266                 fileName, cachedName);
 267             fd = dvmOpenCachedDexFile(fileName, cachedName,
 268                     dexGetZipEntryModTime(&archive, entry),
 269                     dexGetZipEntryCrc32(&archive, entry),
 270                     isBootstrap, &newFile, /*createIfMissing=*/true);
 271             if (fd < 0) {
 272                 ALOGI("Unable to open or create cache for %s (%s)",
 273                     fileName, cachedName);
 274                 goto bail;
 275             }
 276             locked = true;
 277
 278             /*
 279              * If fd points to a new file (because there was no cached version,
 280              * or the cached version was stale), generate the optimized DEX.
 281              * The file descriptor returned is still locked, and is positioned
 282              * just past the optimization header.
 283              */
 284             if (newFile) {
 285                 u8 startWhen, extractWhen, endWhen;
 286                 bool result;
 287                 off_t dexOffset;
 288
 289                 dexOffset = lseek(fd, 0, SEEK_CUR);
 290                 result = (dexOffset > 0);
 291
 292                 if (result) {
 293                     startWhen = dvmGetRelativeTimeUsec();
 294                     result = dexZipExtractEntryToFile(&archive, entry, fd) == 0;
 295                     extractWhen = dvmGetRelativeTimeUsec();
 296                 }
 297                 if (result) {
 298                     result = dvmOptimizeDexFile(fd, dexOffset,
 299                                 dexGetZipEntryUncompLen(&archive, entry),
 300                                 fileName,
 301                                 dexGetZipEntryModTime(&archive, entry),
 302                                 dexGetZipEntryCrc32(&archive, entry),
 303                                 isBootstrap);
 304                 }
 305
 306                 if (!result) {
 307                     ALOGE("Unable to extract+optimize DEX from '%s'",
 308                         fileName);
 309                     goto bail;
 310                 }
 311
 312                 endWhen = dvmGetRelativeTimeUsec();
 313                 ALOGD("DEX prep '%s': unzip in %dms, rewrite %dms",
 314                     fileName,
 315                     (int) (extractWhen - startWhen) / 1000,
 316                     (int) (endWhen - extractWhen) / 1000);
 317             }
 318         } else {
 319             ALOGI("Zip is good, but no %s inside, and no valid .odex "
 320                     "file in the same directory", kDexInJarName);
 321             goto bail;
 322         }
 323     }
 324
 325     /*
 326      * Map the cached version.  This immediately rewinds the fd, so it
 327      * doesn't have to be seeked anywhere in particular.
 328      */
 329     if (dvmDexFileOpenFromFd(fd, &pDvmDex) != 0) {
 330         ALOGI("Unable to map %s in %s", kDexInJarName, fileName);
 331         goto bail;
 332     }
 333
 334     if (locked) {
 335         /* unlock the fd */
 336         if (!dvmUnlockCachedDexFile(fd)) {
 337             /* uh oh -- this process needs to exit or we'll wedge the system */
 338             ALOGE("Unable to unlock DEX file");
 339             goto bail;
 340         }
 341         locked = false;
 342     }
 343
 344     ALOGV("Successfully opened '%s' in '%s'", kDexInJarName, fileName);
 345
 346     *ppJarFile = (JarFile*) calloc(1, sizeof(JarFile));
 347     (*ppJarFile)->archive = archive;
 348     (*ppJarFile)->cacheFileName = cachedName;
 349     (*ppJarFile)->pDvmDex = pDvmDex;
 350     cachedName = NULL;      // don't free it below
 351     result = 0;
 352
 353 bail:
 354     /* clean up, closing the open file */
 355     if (archiveOpen && result != 0)
 356         dexZipCloseArchive(&archive);
 357     free(cachedName);
 358     if (fd >= 0) {
 359         if (locked)
 360             (void) dvmUnlockCachedDexFile(fd);
 361         close(fd);
 362     }
 363     return result;
 364 }
 365
 366 /*
 367  * Close a Jar file and free the struct.
 368  */
 369 void dvmJarFileFree(JarFile* pJarFile)
 370 {
 371     if (pJarFile == NULL)
 372         return;
 373
 374     dvmDexFileFree(pJarFile->pDvmDex);
 375     dexZipCloseArchive(&pJarFile->archive);
 376     free(pJarFile->cacheFileName);
 377     free(pJarFile);
 378 }