blob: 9138878ff776b7d846cc17d14785aeb13e0ba5f9 [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/*
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// Misc zip/gzip utility functions.
19//
20
21#define LOG_TAG "ziputil"
22
Mathias Agopian8ae23352009-06-04 13:53:57 -070023#include <utils/ZipUtils.h>
24#include <utils/ZipFileRO.h>
25#include <utils/Log.h>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080026
27#include <stdlib.h>
28#include <string.h>
29#include <assert.h>
30
31#include <zlib.h>
32
33using namespace android;
34
35/*
36 * Utility function that expands zip/gzip "deflate" compressed data
37 * into a buffer.
38 *
39 * "fd" is an open file positioned at the start of the "deflate" data
40 * "buf" must hold at least "uncompressedLen" bytes.
41 */
42/*static*/ bool ZipUtils::inflateToBuffer(int fd, void* buf,
43 long uncompressedLen, long compressedLen)
44{
45 bool result = false;
46 const unsigned long kReadBufSize = 32768;
47 unsigned char* readBuf = NULL;
48 z_stream zstream;
49 int zerr;
50 unsigned long compRemaining;
51
52 assert(uncompressedLen >= 0);
53 assert(compressedLen >= 0);
54
55 readBuf = new unsigned char[kReadBufSize];
56 if (readBuf == NULL)
57 goto bail;
58 compRemaining = compressedLen;
59
60 /*
61 * Initialize the zlib stream.
62 */
63 memset(&zstream, 0, sizeof(zstream));
64 zstream.zalloc = Z_NULL;
65 zstream.zfree = Z_NULL;
66 zstream.opaque = Z_NULL;
67 zstream.next_in = NULL;
68 zstream.avail_in = 0;
69 zstream.next_out = (Bytef*) buf;
70 zstream.avail_out = uncompressedLen;
71 zstream.data_type = Z_UNKNOWN;
72
73 /*
74 * Use the undocumented "negative window bits" feature to tell zlib
75 * that there's no zlib header waiting for it.
76 */
77 zerr = inflateInit2(&zstream, -MAX_WBITS);
78 if (zerr != Z_OK) {
79 if (zerr == Z_VERSION_ERROR) {
80 LOGE("Installed zlib is not compatible with linked version (%s)\n",
81 ZLIB_VERSION);
82 } else {
83 LOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
84 }
85 goto bail;
86 }
87
88 /*
89 * Loop while we have data.
90 */
91 do {
92 unsigned long getSize;
93
94 /* read as much as we can */
95 if (zstream.avail_in == 0) {
96 getSize = (compRemaining > kReadBufSize) ?
97 kReadBufSize : compRemaining;
98 LOGV("+++ reading %ld bytes (%ld left)\n",
99 getSize, compRemaining);
100
101 int cc = read(fd, readBuf, getSize);
102 if (cc != (int) getSize) {
103 LOGD("inflate read failed (%d vs %ld)\n",
104 cc, getSize);
105 goto z_bail;
106 }
107
108 compRemaining -= getSize;
109
110 zstream.next_in = readBuf;
111 zstream.avail_in = getSize;
112 }
113
114 /* uncompress the data */
115 zerr = inflate(&zstream, Z_NO_FLUSH);
116 if (zerr != Z_OK && zerr != Z_STREAM_END) {
117 LOGD("zlib inflate call failed (zerr=%d)\n", zerr);
118 goto z_bail;
119 }
120
121 /* output buffer holds all, so no need to write the output */
122 } while (zerr == Z_OK);
123
124 assert(zerr == Z_STREAM_END); /* other errors should've been caught */
125
126 if ((long) zstream.total_out != uncompressedLen) {
127 LOGW("Size mismatch on inflated file (%ld vs %ld)\n",
128 zstream.total_out, uncompressedLen);
129 goto z_bail;
130 }
131
132 // success!
133 result = true;
134
135z_bail:
136 inflateEnd(&zstream); /* free up any allocated structures */
137
138bail:
139 delete[] readBuf;
140 return result;
141}
142
143/*
144 * Utility function that expands zip/gzip "deflate" compressed data
145 * into a buffer.
146 *
147 * (This is a clone of the previous function, but it takes a FILE* instead
148 * of an fd. We could pass fileno(fd) to the above, but we can run into
149 * trouble when "fp" has a different notion of what fd's file position is.)
150 *
151 * "fp" is an open file positioned at the start of the "deflate" data
152 * "buf" must hold at least "uncompressedLen" bytes.
153 */
154/*static*/ bool ZipUtils::inflateToBuffer(FILE* fp, void* buf,
155 long uncompressedLen, long compressedLen)
156{
157 bool result = false;
158 const unsigned long kReadBufSize = 32768;
159 unsigned char* readBuf = NULL;
160 z_stream zstream;
161 int zerr;
162 unsigned long compRemaining;
163
164 assert(uncompressedLen >= 0);
165 assert(compressedLen >= 0);
166
167 readBuf = new unsigned char[kReadBufSize];
168 if (readBuf == NULL)
169 goto bail;
170 compRemaining = compressedLen;
171
172 /*
173 * Initialize the zlib stream.
174 */
175 memset(&zstream, 0, sizeof(zstream));
176 zstream.zalloc = Z_NULL;
177 zstream.zfree = Z_NULL;
178 zstream.opaque = Z_NULL;
179 zstream.next_in = NULL;
180 zstream.avail_in = 0;
181 zstream.next_out = (Bytef*) buf;
182 zstream.avail_out = uncompressedLen;
183 zstream.data_type = Z_UNKNOWN;
184
185 /*
186 * Use the undocumented "negative window bits" feature to tell zlib
187 * that there's no zlib header waiting for it.
188 */
189 zerr = inflateInit2(&zstream, -MAX_WBITS);
190 if (zerr != Z_OK) {
191 if (zerr == Z_VERSION_ERROR) {
192 LOGE("Installed zlib is not compatible with linked version (%s)\n",
193 ZLIB_VERSION);
194 } else {
195 LOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
196 }
197 goto bail;
198 }
199
200 /*
201 * Loop while we have data.
202 */
203 do {
204 unsigned long getSize;
205
206 /* read as much as we can */
207 if (zstream.avail_in == 0) {
208 getSize = (compRemaining > kReadBufSize) ?
209 kReadBufSize : compRemaining;
210 LOGV("+++ reading %ld bytes (%ld left)\n",
211 getSize, compRemaining);
212
Doug Zongkerd2792e32009-07-16 11:27:13 -0700213 int cc = fread(readBuf, 1, getSize, fp);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800214 if (cc != (int) getSize) {
215 LOGD("inflate read failed (%d vs %ld)\n",
216 cc, getSize);
217 goto z_bail;
218 }
219
220 compRemaining -= getSize;
221
222 zstream.next_in = readBuf;
223 zstream.avail_in = getSize;
224 }
225
226 /* uncompress the data */
227 zerr = inflate(&zstream, Z_NO_FLUSH);
228 if (zerr != Z_OK && zerr != Z_STREAM_END) {
229 LOGD("zlib inflate call failed (zerr=%d)\n", zerr);
230 goto z_bail;
231 }
232
233 /* output buffer holds all, so no need to write the output */
234 } while (zerr == Z_OK);
235
236 assert(zerr == Z_STREAM_END); /* other errors should've been caught */
237
238 if ((long) zstream.total_out != uncompressedLen) {
239 LOGW("Size mismatch on inflated file (%ld vs %ld)\n",
240 zstream.total_out, uncompressedLen);
241 goto z_bail;
242 }
243
244 // success!
245 result = true;
246
247z_bail:
248 inflateEnd(&zstream); /* free up any allocated structures */
249
250bail:
251 delete[] readBuf;
252 return result;
253}
254
255/*
256 * Look at the contents of a gzip archive. We want to know where the
257 * data starts, and how long it will be after it is uncompressed.
258 *
259 * We expect to find the CRC and length as the last 8 bytes on the file.
260 * This is a pretty reasonable thing to expect for locally-compressed
261 * files, but there's a small chance that some extra padding got thrown
262 * on (the man page talks about compressed data written to tape). We
263 * don't currently deal with that here. If "gzip -l" whines, we're going
264 * to fail too.
265 *
266 * On exit, "fp" is pointing at the start of the compressed data.
267 */
268/*static*/ bool ZipUtils::examineGzip(FILE* fp, int* pCompressionMethod,
269 long* pUncompressedLen, long* pCompressedLen, unsigned long* pCRC32)
270{
271 enum { // flags
272 FTEXT = 0x01,
273 FHCRC = 0x02,
274 FEXTRA = 0x04,
275 FNAME = 0x08,
276 FCOMMENT = 0x10,
277 };
278 int ic;
279 int method, flags;
280 int i;
281
282 ic = getc(fp);
283 if (ic != 0x1f || getc(fp) != 0x8b)
284 return false; // not gzip
285 method = getc(fp);
286 flags = getc(fp);
287
288 /* quick sanity checks */
289 if (method == EOF || flags == EOF)
290 return false;
291 if (method != ZipFileRO::kCompressDeflated)
292 return false;
293
294 /* skip over 4 bytes of mod time, 1 byte XFL, 1 byte OS */
295 for (i = 0; i < 6; i++)
296 (void) getc(fp);
297 /* consume "extra" field, if present */
298 if ((flags & FEXTRA) != 0) {
299 int len;
300
301 len = getc(fp);
302 len |= getc(fp) << 8;
303 while (len-- && getc(fp) != EOF)
304 ;
305 }
306 /* consume filename, if present */
307 if ((flags & FNAME) != 0) {
308 do {
309 ic = getc(fp);
310 } while (ic != 0 && ic != EOF);
311 }
312 /* consume comment, if present */
313 if ((flags & FCOMMENT) != 0) {
314 do {
315 ic = getc(fp);
316 } while (ic != 0 && ic != EOF);
317 }
318 /* consume 16-bit header CRC, if present */
319 if ((flags & FHCRC) != 0) {
320 (void) getc(fp);
321 (void) getc(fp);
322 }
323
324 if (feof(fp) || ferror(fp))
325 return false;
326
327 /* seek to the end; CRC and length are in the last 8 bytes */
328 long curPosn = ftell(fp);
329 unsigned char buf[8];
330 fseek(fp, -8, SEEK_END);
331 *pCompressedLen = ftell(fp) - curPosn;
332
333 if (fread(buf, 1, 8, fp) != 8)
334 return false;
335 /* seek back to start of compressed data */
336 fseek(fp, curPosn, SEEK_SET);
337
338 *pCompressionMethod = method;
339 *pCRC32 = ZipFileRO::get4LE(&buf[0]);
340 *pUncompressedLen = ZipFileRO::get4LE(&buf[4]);
341
342 return true;
343}