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:
ZipFile(void)46     ZipFile(void)
47       : mZipFp(NULL), mReadOnly(false), mNeedCDRewrite(false)
48       {}
~ZipFile(void)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      */
add(const char * fileName,int compressionMethod,ZipEntry ** ppEntry)80     status_t add(const char* fileName, int compressionMethod,
81         ZipEntry** ppEntry)
82     {
83         return add(fileName, fileName, compressionMethod, ppEntry);
84     }
add(const char * fileName,const char * storageName,int compressionMethod,ZipEntry ** ppEntry)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      */
addGzip(const char * fileName,const char * storageName,ZipEntry ** ppEntry)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      */
add(const void * data,size_t size,const char * storageName,int compressionMethod,ZipEntry ** ppEntry)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      */
getNumEntries(void)164     int getNumEntries(void) const { return mEntries.size(); }
165     ZipEntry* getEntryByIndex(int idx) const;
166 
167 private:
168     /* these are private and not defined */
169     ZipFile(const ZipFile& src);
170     ZipFile& operator=(const ZipFile& src);
171 
172     class EndOfCentralDir {
173     public:
EndOfCentralDir(void)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             {}
~EndOfCentralDir(void)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