libdex/CmdUtils.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  * Some utility functions for use with command-line utilities.
  18  */
  19 #include "DexFile.h"
  20 #include "ZipArchive.h"
  21 #include "CmdUtils.h"
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <fcntl.h>
  26 #include <errno.h>
  27
  28 #ifndef O_BINARY
  29 #define O_BINARY 0
  30 #endif
  31
  32 /*
  33  * Extract "classes.dex" from archive file.
  34  *
  35  * If "quiet" is set, don't report common errors.
  36  */
  37 UnzipToFileResult dexUnzipToFile(const char* zipFileName,
  38     const char* outFileName, bool quiet)
  39 {
  40     UnzipToFileResult result = kUTFRSuccess;
  41     static const char* kFileToExtract = "classes.dex";
  42     ZipArchive archive;
  43     ZipEntry entry;
  44     bool unlinkOnFailure = false;
  45     int fd = -1;
  46
  47     if (dexZipOpenArchive(zipFileName, &archive) != 0) {
  48         if (!quiet) {
  49             fprintf(stderr, "Unable to open '%s' as zip archive\n",
  50                 zipFileName);
  51         }
  52         result = kUTFRNotZip;
  53         goto bail;
  54     }
  55
  56     fd = open(outFileName, O_WRONLY | O_CREAT | O_EXCL, 0600);
  57     if (fd < 0) {
  58         fprintf(stderr, "Unable to create output file '%s': %s\n",
  59             outFileName, strerror(errno));
  60         result = kUTFROutputFileProblem;
  61         goto bail;
  62     }
  63
  64     unlinkOnFailure = true;
  65
  66     entry = dexZipFindEntry(&archive, kFileToExtract);
  67     if (entry == NULL) {
  68         if (!quiet) {
  69             fprintf(stderr, "Unable to find '%s' in '%s'\n",
  70                 kFileToExtract, zipFileName);
  71         }
  72         result = kUTFRNoClassesDex;
  73         goto bail;
  74     }
  75
  76     if (dexZipExtractEntryToFile(&archive, entry, fd) != 0) {
  77         fprintf(stderr, "Extract of '%s' from '%s' failed\n",
  78             kFileToExtract, zipFileName);
  79         result = kUTFRBadZip;
  80         goto bail;
  81     }
  82
  83 bail:
  84     if (fd >= 0)
  85         close(fd);
  86     if (unlinkOnFailure && result != kUTFRSuccess)
  87         unlink(outFileName);
  88     dexZipCloseArchive(&archive);
  89     return result;
  90 }
  91
  92 /*
  93  * Map the specified DEX file read-only (possibly after expanding it into a
  94  * temp file from a Jar).  Pass in a MemMapping struct to hold the info.
  95  * If the file is an unoptimized DEX file, then byte-swapping and structural
  96  * verification are performed on it before the memory is made read-only.
  97  *
  98  * The temp file is deleted after the map succeeds.
  99  *
 100  * This is intended for use by tools (e.g. dexdump) that need to get a
 101  * read-only copy of a DEX file that could be in a number of different states.
 102  *
 103  * If "tempFileName" is NULL, a default value is used.  The temp file is
 104  * deleted after the map succeeds.
 105  *
 106  * If "quiet" is set, don't report common errors.
 107  *
 108  * Returns 0 (kUTFRSuccess) on success.
 109  */
 110 UnzipToFileResult dexOpenAndMap(const char* fileName, const char* tempFileName,
 111     MemMapping* pMap, bool quiet)
 112 {
 113     UnzipToFileResult result = kUTFRGenericFailure;
 114     int len = strlen(fileName);
 115     char tempNameBuf[32];
 116     bool removeTemp = false;
 117     int fd = -1;
 118
 119     if (len < 5) {
 120         if (!quiet) {
 121             fprintf(stderr,
 122                 "ERROR: filename must end in .dex, .zip, .jar, or .apk\n");
 123         }
 124         result = kUTFRBadArgs;
 125         goto bail;
 126     }
 127
 128     if (strcasecmp(fileName + len -3, "dex") != 0) {
 129         if (tempFileName == NULL) {
 130             /*
 131              * Try .zip/.jar/.apk, all of which are Zip archives with
 132              * "classes.dex" inside.  We need to extract the compressed
 133              * data to a temp file, the location of which varies.
 134              *
 135              * On the device we must use /sdcard because most other
 136              * directories aren't writable (either because of permissions
 137              * or because the volume is mounted read-only).  On desktop
 138              * it's nice to use the designated temp directory.
 139              */
 140             if (access("/tmp", W_OK) == 0) {
 141                 sprintf(tempNameBuf, "/tmp/dex-temp-%d", getpid());
 142             } else if (access("/sdcard", W_OK) == 0) {
 143                 sprintf(tempNameBuf, "/sdcard/dex-temp-%d", getpid());
 144             } else {
 145                 fprintf(stderr,
 146                     "NOTE: /tmp and /sdcard unavailable for temp files\n");
 147                 sprintf(tempNameBuf, "dex-temp-%d", getpid());
 148             }
 149
 150             tempFileName = tempNameBuf;
 151         }
 152
 153         result = dexUnzipToFile(fileName, tempFileName, quiet);
 154
 155         if (result == kUTFRSuccess) {
 156             //printf("+++ Good unzip to '%s'\n", tempFileName);
 157             fileName = tempFileName;
 158             removeTemp = true;
 159         } else if (result == kUTFRNotZip) {
 160             if (!quiet) {
 161                 fprintf(stderr, "Not Zip, retrying as DEX\n");
 162             }
 163         } else {
 164             if (!quiet && result == kUTFRNoClassesDex) {
 165                 fprintf(stderr, "Zip has no classes.dex\n");
 166             }
 167             goto bail;
 168         }
 169     }
 170
 171     result = kUTFRGenericFailure;
 172
 173     /*
 174      * Pop open the (presumed) DEX file.
 175      */
 176     fd = open(fileName, O_RDONLY | O_BINARY);
 177     if (fd < 0) {
 178         if (!quiet) {
 179             fprintf(stderr, "ERROR: unable to open '%s': %s\n",
 180                 fileName, strerror(errno));
 181         }
 182         goto bail;
 183     }
 184
 185     if (sysMapFileInShmemWritableReadOnly(fd, pMap) != 0) {
 186         fprintf(stderr, "ERROR: Unable to map '%s'\n", fileName);
 187         goto bail;
 188     }
 189
 190     /*
 191      * This call will fail if the file exists on a filesystem that
 192      * doesn't support mprotect(). If that's the case, then the file
 193      * will have already been mapped private-writable by the previous
 194      * call, so we don't need to do anything special if this call
 195      * returns non-zero.
 196      */
 197     sysChangeMapAccess(pMap->addr, pMap->length, true, pMap);
 198
 199     if (dexSwapAndVerifyIfNecessary(pMap->addr, pMap->length)) {
 200         fprintf(stderr, "ERROR: Failed structural verification of '%s'\n",
 201             fileName);
 202         goto bail;
 203     }
 204
 205     /*
 206      * Similar to above, this call will fail if the file wasn't ever
 207      * read-only to begin with. This is innocuous, though it is
 208      * undesirable from a memory hygiene perspective.
 209      */
 210     sysChangeMapAccess(pMap->addr, pMap->length, false, pMap);
 211
 212     /*
 213      * Success!  Close the file and return with the start/length in pMap.
 214      */
 215     result = 0;
 216
 217 bail:
 218     if (fd >= 0)
 219         close(fd);
 220     if (removeTemp) {
 221         /* this will fail if the OS doesn't allow removal of a mapped file */
 222         if (unlink(tempFileName) != 0) {
 223             fprintf(stderr, "WARNING: unable to remove temp '%s'\n",
 224                 tempFileName);
 225         }
 226     }
 227     return result;
 228 }