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
30namespace 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 */
44class ZipFile {
45public:
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     * Mark an entry as having been removed.  It is not actually deleted
131     * from the archive or our internal data structures until flush() is
132     * called.
133     */
134    status_t remove(ZipEntry* pEntry);
135
136    /*
137     * Flush changes.  If mNeedCDRewrite is set, this writes the central dir.
138     */
139    status_t flush(void);
140
141    /*
142     * Expand the data into the buffer provided.  The buffer must hold
143     * at least <uncompressed len> bytes.  Variation expands directly
144     * to a file.
145     *
146     * Returns "false" if an error was encountered in the compressed data.
147     */
148    //bool uncompress(const ZipEntry* pEntry, void* buf) const;
149    //bool uncompress(const ZipEntry* pEntry, FILE* fp) const;
150    void* uncompress(const ZipEntry* pEntry);
151
152    /*
153     * Get an entry, by name.  Returns NULL if not found.
154     *
155     * Does not return entries pending deletion.
156     */
157    ZipEntry* getEntryByName(const char* fileName) const;
158
159    /*
160     * Get the Nth entry in the archive.
161     *
162     * This will return an entry that is pending deletion.
163     */
164    int getNumEntries(void) const { return mEntries.size(); }
165    ZipEntry* getEntryByIndex(int idx) const;
166
167private:
168    /* these are private and not defined */
169    ZipFile(const ZipFile& src);
170    ZipFile& operator=(const ZipFile& src);
171
172    class EndOfCentralDir {
173    public:
174        EndOfCentralDir(void) :
175            mDiskNumber(0),
176            mDiskWithCentralDir(0),
177            mNumEntries(0),
178            mTotalNumEntries(0),
179            mCentralDirSize(0),
180            mCentralDirOffset(0),
181            mCommentLen(0),
182            mComment(NULL)
183            {}
184        virtual ~EndOfCentralDir(void) {
185            delete[] mComment;
186        }
187
188        status_t readBuf(const unsigned char* buf, int len);
189        status_t write(FILE* fp);
190
191        //unsigned long   mSignature;
192        unsigned short  mDiskNumber;
193        unsigned short  mDiskWithCentralDir;
194        unsigned short  mNumEntries;
195        unsigned short  mTotalNumEntries;
196        unsigned long   mCentralDirSize;
197        unsigned long   mCentralDirOffset;      // offset from first disk
198        unsigned short  mCommentLen;
199        unsigned char*  mComment;
200
201        enum {
202            kSignature      = 0x06054b50,
203            kEOCDLen        = 22,       // EndOfCentralDir len, excl. comment
204
205            kMaxCommentLen  = 65535,    // longest possible in ushort
206            kMaxEOCDSearch  = kMaxCommentLen + EndOfCentralDir::kEOCDLen,
207
208        };
209
210        void dump(void) const;
211    };
212
213
214    /* read all entries in the central dir */
215    status_t readCentralDir(void);
216
217    /* crunch deleted entries out */
218    status_t crunchArchive(void);
219
220    /* clean up mEntries */
221    void discardEntries(void);
222
223    /* common handler for all "add" functions */
224    status_t addCommon(const char* fileName, const void* data, size_t size,
225        const char* storageName, int sourceType, int compressionMethod,
226        ZipEntry** ppEntry);
227
228    /* copy all of "srcFp" into "dstFp" */
229    status_t copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32);
230    /* copy all of "data" into "dstFp" */
231    status_t copyDataToFp(FILE* dstFp,
232        const void* data, size_t size, unsigned long* pCRC32);
233    /* copy some of "srcFp" into "dstFp" */
234    status_t copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length,
235        unsigned long* pCRC32);
236    /* like memmove(), but on parts of a single file */
237    status_t filemove(FILE* fp, off_t dest, off_t src, size_t n);
238    /* compress all of "srcFp" into "dstFp", using Deflate */
239    status_t compressFpToFp(FILE* dstFp, FILE* srcFp,
240        const void* data, size_t size, unsigned long* pCRC32);
241
242    /* get modification date from a file descriptor */
243    time_t getModTime(int fd);
244
245    /*
246     * We use stdio FILE*, which gives us buffering but makes dealing
247     * with files >2GB awkward.  Until we support Zip64, we're fine.
248     */
249    FILE*           mZipFp;             // Zip file pointer
250
251    /* one of these per file */
252    EndOfCentralDir mEOCD;
253
254    /* did we open this read-only? */
255    bool            mReadOnly;
256
257    /* set this when we trash the central dir */
258    bool            mNeedCDRewrite;
259
260    /*
261     * One ZipEntry per entry in the zip file.  I'm using pointers instead
262     * of objects because it's easier than making operator= work for the
263     * classes and sub-classes.
264     */
265    Vector<ZipEntry*>   mEntries;
266};
267
268}; // namespace android
269
270#endif // __LIBS_ZIPFILE_H
271