vm/JarFile.c

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