tools/zipalign/ZipFile.h

   1 /*
   2  * Copyright (C) 2006 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 // General-purpose Zip archive access.  This class allows both reading and
  19 // writing to Zip archives, including deletion of existing entries.
  20 //
  21 #ifndef __LIBS_ZIPFILE_H
  22 #define __LIBS_ZIPFILE_H
  23
  24 #include <utils/Vector.h>
  25 #include <utils/Errors.h>
  26 #include <stdio.h>
  27
  28 #include "ZipEntry.h"
  29
  30 namespace android {
  31
  32 /*
  33  * Manipulate a Zip archive.
  34  *
  35  * Some changes will not be visible in the until until "flush" is called.
  36  *
  37  * The correct way to update a file archive is to make all changes to a
  38  * copy of the archive in a temporary file, and then unlink/rename over
  39  * the original after everything completes.  Because we're only interested
  40  * in using this for packaging, we don't worry about such things.  Crashing
  41  * after making changes and before flush() completes could leave us with
  42  * an unusable Zip archive.
  43  */
  44 class ZipFile {
  45 public:
  46     ZipFile(void)
  47       : mZipFp(NULL), mReadOnly(false), mNeedCDRewrite(false)
  48       {}
  49     ~ZipFile(void) {
  50         if (!mReadOnly)
  51             flush();
  52         if (mZipFp != NULL)
  53             fclose(mZipFp);
  54         discardEntries();
  55     }
  56
  57     /*
  58      * Open a new or existing archive.
  59      */
  60     enum {
  61         kOpenReadOnly   = 0x01,
  62         kOpenReadWrite  = 0x02,
  63         kOpenCreate     = 0x04,     // create if it doesn't exist
  64         kOpenTruncate   = 0x08,     // if it exists, empty it
  65     };
  66     status_t open(const char* zipFileName, int flags);
  67
  68     /*
  69      * Add a file to the end of the archive.  Specify whether you want the
  70      * library to try to store it compressed.
  71      *
  72      * If "storageName" is specified, the archive will use that instead
  73      * of "fileName".
  74      *
  75      * If there is already an entry with the same name, the call fails.
  76      * Existing entries with the same name must be removed first.
  77      *
  78      * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
  79      */
  80     status_t add(const char* fileName, int compressionMethod,
  81         ZipEntry** ppEntry)
  82     {
  83         return add(fileName, fileName, compressionMethod, ppEntry);
  84     }
  85     status_t add(const char* fileName, const char* storageName,
  86         int compressionMethod, ZipEntry** ppEntry)
  87     {
  88         return addCommon(fileName, NULL, 0, storageName,
  89                          ZipEntry::kCompressStored,
  90                          compressionMethod, ppEntry);
  91     }
  92
  93     /*
  94      * Add a file that is already compressed with gzip.
  95      *
  96      * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
  97      */
  98     status_t addGzip(const char* fileName, const char* storageName,
  99         ZipEntry** ppEntry)
 100     {
 101         return addCommon(fileName, NULL, 0, storageName,
 102                          ZipEntry::kCompressDeflated,
 103                          ZipEntry::kCompressDeflated, ppEntry);
 104     }
 105
 106     /*
 107      * Add a file from an in-memory data buffer.
 108      *
 109      * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
 110      */
 111     status_t add(const void* data, size_t size, const char* storageName,
 112         int compressionMethod, ZipEntry** ppEntry)
 113     {
 114         return addCommon(NULL, data, size, storageName,
 115                          ZipEntry::kCompressStored,
 116                          compressionMethod, ppEntry);
 117     }
 118
 119     /*
 120      * Add an entry by copying it from another zip file.  If "padding" is
 121      * nonzero, the specified number of bytes will be added to the "extra"
 122      * field in the header.
 123      *
 124      * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
 125      */
 126     status_t add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry,
 127         int padding, ZipEntry** ppEntry);
 128
 129     /*
 130      * Add an entry by copying it from another zip file, recompressing with
 131      * Zopfli if already compressed.
 132      *
 133      * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
 134      */
 135     status_t addRecompress(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry,
 136         ZipEntry** ppEntry);
 137
 138     /*
 139      * Mark an entry as having been removed.  It is not actually deleted
 140      * from the archive or our internal data structures until flush() is
 141      * called.
 142      */
 143     status_t remove(ZipEntry* pEntry);
 144
 145     /*
 146      * Flush changes.  If mNeedCDRewrite is set, this writes the central dir.
 147      */
 148     status_t flush(void);
 149
 150     /*
 151      * Expand the data into the buffer provided.  The buffer must hold
 152      * at least <uncompressed len> bytes.  Variation expands directly
 153      * to a file.
 154      *
 155      * Returns "false" if an error was encountered in the compressed data.
 156      */
 157     //bool uncompress(const ZipEntry* pEntry, void* buf) const;
 158     //bool uncompress(const ZipEntry* pEntry, FILE* fp) const;
 159     void* uncompress(const ZipEntry* pEntry) const;
 160
 161     /*
 162      * Get an entry, by name.  Returns NULL if not found.
 163      *
 164      * Does not return entries pending deletion.
 165      */
 166     ZipEntry* getEntryByName(const char* fileName) const;
 167
 168     /*
 169      * Get the Nth entry in the archive.
 170      *
 171      * This will return an entry that is pending deletion.
 172      */
 173     int getNumEntries(void) const { return mEntries.size(); }
 174     ZipEntry* getEntryByIndex(int idx) const;
 175
 176 private:
 177     /* these are private and not defined */
 178     ZipFile(const ZipFile& src);
 179     ZipFile& operator=(const ZipFile& src);
 180
 181     class EndOfCentralDir {
 182     public:
 183         EndOfCentralDir(void) :
 184             mDiskNumber(0),
 185             mDiskWithCentralDir(0),
 186             mNumEntries(0),
 187             mTotalNumEntries(0),
 188             mCentralDirSize(0),
 189             mCentralDirOffset(0),
 190             mCommentLen(0),
 191             mComment(NULL)
 192             {}
 193         virtual ~EndOfCentralDir(void) {
 194             delete[] mComment;
 195         }
 196
 197         status_t readBuf(const unsigned char* buf, int len);
 198         status_t write(FILE* fp);
 199
 200         //unsigned long   mSignature;
 201         unsigned short  mDiskNumber;
 202         unsigned short  mDiskWithCentralDir;
 203         unsigned short  mNumEntries;
 204         unsigned short  mTotalNumEntries;
 205         unsigned long   mCentralDirSize;
 206         unsigned long   mCentralDirOffset;      // offset from first disk
 207         unsigned short  mCommentLen;
 208         unsigned char*  mComment;
 209
 210         enum {
 211             kSignature      = 0x06054b50,
 212             kEOCDLen        = 22,       // EndOfCentralDir len, excl. comment
 213
 214             kMaxCommentLen  = 65535,    // longest possible in ushort
 215             kMaxEOCDSearch  = kMaxCommentLen + EndOfCentralDir::kEOCDLen,
 216
 217         };
 218
 219         void dump(void) const;
 220     };
 221
 222
 223     /* read all entries in the central dir */
 224     status_t readCentralDir(void);
 225
 226     /* crunch deleted entries out */
 227     status_t crunchArchive(void);
 228
 229     /* clean up mEntries */
 230     void discardEntries(void);
 231
 232     /* common handler for all "add" functions */
 233     status_t addCommon(const char* fileName, const void* data, size_t size,
 234         const char* storageName, int sourceType, int compressionMethod,
 235         ZipEntry** ppEntry);
 236
 237     /* copy all of "srcFp" into "dstFp" */
 238     status_t copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32);
 239     /* copy all of "data" into "dstFp" */
 240     status_t copyDataToFp(FILE* dstFp,
 241         const void* data, size_t size, unsigned long* pCRC32);
 242     /* copy some of "srcFp" into "dstFp" */
 243     status_t copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length,
 244         unsigned long* pCRC32);
 245     /* like memmove(), but on parts of a single file */
 246     status_t filemove(FILE* fp, off_t dest, off_t src, size_t n);
 247     /* compress all of "srcFp" into "dstFp", using Deflate */
 248     status_t compressFpToFp(FILE* dstFp, FILE* srcFp,
 249         const void* data, size_t size, unsigned long* pCRC32);
 250
 251     /* get modification date from a file descriptor */
 252     time_t getModTime(int fd);
 253
 254     /*
 255      * We use stdio FILE*, which gives us buffering but makes dealing
 256      * with files >2GB awkward.  Until we support Zip64, we're fine.
 257      */
 258     FILE*           mZipFp;             // Zip file pointer
 259
 260     /* one of these per file */
 261     EndOfCentralDir mEOCD;
 262
 263     /* did we open this read-only? */
 264     bool            mReadOnly;
 265
 266     /* set this when we trash the central dir */
 267     bool            mNeedCDRewrite;
 268
 269     /*
 270      * One ZipEntry per entry in the zip file.  I'm using pointers instead
 271      * of objects because it's easier than making operator= work for the
 272      * classes and sub-classes.
 273      */
 274     Vector<ZipEntry*>   mEntries;
 275 };
 276
 277 }; // namespace android
 278
 279 #endif // __LIBS_ZIPFILE_H