1 /*
2  * Copyright (C) 2007 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  * Read-only access to Zip archives, with minimal heap allocation.
19  *
20  * This is similar to the more-complete ZipFile class, but no attempt
21  * has been made to make them interchangeable.  This class operates under
22  * a very different set of assumptions and constraints.
23  *
24  * One such assumption is that if you're getting file descriptors for
25  * use with this class as a child of a fork() operation, you must be on
26  * a pread() to guarantee correct operation. This is because pread() can
27  * atomically read at a file offset without worrying about a lock around an
28  * lseek() + read() pair.
29  */
30 #ifndef __LIBS_ZIPFILERO_H
31 #define __LIBS_ZIPFILERO_H
32 
33 #include <utils/Compat.h>
34 #include <utils/Errors.h>
35 #include <utils/FileMap.h>
36 #include <utils/threads.h>
37 
38 #include <stdint.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <time.h>
43 
44 struct ZipArchive;
45 typedef ZipArchive* ZipArchiveHandle;
46 
47 namespace android {
48 
49 /*
50  * Trivial typedef to ensure that ZipEntryRO is not treated as a simple
51  * integer.  We use NULL to indicate an invalid value.
52  */
53 typedef void* ZipEntryRO;
54 
55 /*
56  * Open a Zip archive for reading.
57  *
58  * Implemented as a thin wrapper over system/core/libziparchive.
59  *
60  * "open" and "find entry by name" are fast operations and use as little
61  * memory as possible.
62  *
63  * We also support fast iteration over all entries in the file (with a
64  * stable, but unspecified iteration order).
65  *
66  * NOTE: If this is used on file descriptors inherited from a fork() operation,
67  * you must be on a platform that implements pread() to guarantee correctness
68  * on the shared file descriptors.
69  */
70 class ZipFileRO {
71 public:
72     /* Zip compression methods we support */
73     enum : uint16_t {
74         kCompressStored = 0,
75         kCompressDeflated = 8
76     };
77 
78     /*
79      * Open an archive.
80      */
81     static ZipFileRO* open(const char* zipFileName);
82 
83     /*
84      * Open an archive from an already open file descriptor.
85      */
86     static ZipFileRO* openFd(int fd, const char* debugFileName,
87         bool assume_ownership = true);
88 
89     /*
90      * Find an entry, by name.  Returns the entry identifier, or NULL if
91      * not found.
92      */
93     ZipEntryRO findEntryByName(const char* entryName) const;
94 
95 
96     /*
97      * Start iterating over the list of entries in the zip file. Requires
98      * a matching call to endIteration with the same cookie.
99      */
100     bool startIteration(void** cookie);
101     bool startIteration(void** cookie, const char* prefix, const char* suffix);
102 
103     /**
104      * Return the next entry in iteration order, or NULL if there are no more
105      * entries in this archive.
106      */
107     ZipEntryRO nextEntry(void* cookie);
108 
109     void endIteration(void* cookie);
110 
111     void releaseEntry(ZipEntryRO entry) const;
112 
113     /*
114      * Return the #of entries in the Zip archive.
115      */
116     int getNumEntries();
117 
118     /*
119      * Copy the filename into the supplied buffer.  Returns 0 on success,
120      * -1 if "entry" is invalid, or the filename length if it didn't fit. The
121      * length, and the returned string, include the null-termination.
122      */
123     int getEntryFileName(ZipEntryRO entry, char* buffer, size_t bufLen) const;
124 
125     /*
126      * Get the vital stats for an entry.  Pass in NULL pointers for anything
127      * you don't need.
128      *
129      * "*pOffset" holds the Zip file offset of the entry's data.
130      *
131      * Returns "false" if "entry" is bogus or if the data in the Zip file
132      * appears to be bad.
133      */
134     bool getEntryInfo(ZipEntryRO entry, uint16_t* pMethod, uint32_t* pUncompLen,
135         uint32_t* pCompLen, off64_t* pOffset, uint32_t* pModWhen,
136         uint32_t* pCrc32) const;
137 
138     /*
139      * Create a new FileMap object that maps a subset of the archive.  For
140      * an uncompressed entry this effectively provides a pointer to the
141      * actual data, for a compressed entry this provides the input buffer
142      * for inflate().
143      */
144     FileMap* createEntryFileMap(ZipEntryRO entry) const;
145 
146     /*
147      * Uncompress the data into a buffer.  Depending on the compression
148      * format, this is either an "inflate" operation or a memcpy.
149      *
150      * Use "uncompLen" from getEntryInfo() to determine the required
151      * buffer size.
152      *
153      * Returns "true" on success.
154      */
155     bool uncompressEntry(ZipEntryRO entry, void* buffer, size_t size) const;
156 
157     /*
158      * Uncompress the data to an open file descriptor.
159      */
160     bool uncompressEntry(ZipEntryRO entry, int fd) const;
161 
162     ~ZipFileRO();
163 
164 private:
165     /* these are private and not defined */
166     ZipFileRO(const ZipFileRO& src);
167     ZipFileRO& operator=(const ZipFileRO& src);
168 
ZipFileRO(ZipArchiveHandle handle,char * fileName)169     ZipFileRO(ZipArchiveHandle handle, char* fileName) : mHandle(handle),
170         mFileName(fileName)
171     {
172     }
173 
174     const ZipArchiveHandle mHandle;
175     char* mFileName;
176 };
177 
178 }; // namespace android
179 
180 #endif /*__LIBS_ZIPFILERO_H*/
181