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