1 /* 2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <fcntl.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include "jli_util.h" 33 34 #include <zlib.h> 35 #include "manifest_info.h" 36 37 static char *manifest; 38 39 static const char *manifest_name = "META-INF/MANIFEST.MF"; 40 41 /* 42 * Inflate the manifest file (or any file for that matter). 43 * 44 * fd: File descriptor of the jar file. 45 * entry: Contains the information necessary to perform the inflation 46 * (the compressed and uncompressed sizes and the offset in 47 * the file where the compressed data is located). 48 * size_out: Returns the size of the inflated file. 49 * 50 * Upon success, it returns a pointer to a NUL-terminated malloc'd buffer 51 * containing the inflated manifest file. When the caller is done with it, 52 * this buffer should be released by a call to free(). Upon failure, 53 * returns NULL. 54 */ 55 static char * 56 inflate_file(int fd, zentry *entry, int *size_out) 57 { 58 char *in; 59 char *out; 60 z_stream zs; 61 62 if (entry->csize == (size_t) -1 || entry->isize == (size_t) -1 ) 63 return (NULL); 64 if (JLI_Lseek(fd, entry->offset, SEEK_SET) < (jlong)0) 65 return (NULL); 66 if ((in = malloc(entry->csize + 1)) == NULL) 67 return (NULL); 68 if ((size_t)(read(fd, in, (unsigned int)entry->csize)) != entry->csize) { 69 free(in); 70 return (NULL); 71 } 72 if (entry->how == STORED) { 73 *(char *)((size_t)in + entry->csize) = '\0'; 74 if (size_out) { 75 *size_out = (int)entry->csize; 76 } 77 return (in); 78 } else if (entry->how == DEFLATED) { 79 zs.zalloc = (alloc_func)Z_NULL; 80 zs.zfree = (free_func)Z_NULL; 81 zs.opaque = (voidpf)Z_NULL; 82 zs.next_in = (Byte*)in; 83 zs.avail_in = (uInt)entry->csize; 84 if (inflateInit2(&zs, -MAX_WBITS) < 0) { 85 free(in); 86 return (NULL); 87 } 88 if ((out = malloc(entry->isize + 1)) == NULL) { 89 free(in); 90 return (NULL); 91 } 92 zs.next_out = (Byte*)out; 93 zs.avail_out = (uInt)entry->isize; 94 if (inflate(&zs, Z_PARTIAL_FLUSH) < 0) { 95 free(in); 96 free(out); 97 return (NULL); 98 } 99 *(char *)((size_t)out + entry->isize) = '\0'; 100 free(in); 101 if (inflateEnd(&zs) < 0) { 102 free(out); 103 return (NULL); 104 } 105 if (size_out) { 106 *size_out = (int)entry->isize; 107 } 108 return (out); 109 } 110 free(in); 111 return (NULL); 112 } 113 114 /* 115 * Implementation notes: 116 * 117 * This is a zip format reader for seekable files, that tolerates 118 * leading and trailing garbage, and tolerates having had internal 119 * offsets adjusted for leading garbage (as with Info-Zip's zip -A). 120 * 121 * We find the end header by scanning backwards from the end of the 122 * file for the end signature. This may fail in the presence of 123 * trailing garbage or a ZIP file comment that contains binary data. 124 * Similarly, the ZIP64 end header may need to be located by scanning 125 * backwards from the end header. It may be misidentified, but this 126 * is very unlikely to happen in practice without adversarial input. 127 * 128 * The zip file format is documented at: 129 * https://www.pkware.com/documents/casestudies/APPNOTE.TXT 130 * 131 * TODO: more informative error messages 132 */ 133 134 /** Reads count bytes from fd at position pos into given buffer. */ 135 static jboolean 136 readAt(int fd, jlong pos, unsigned int count, void *buf) { 137 return (pos >= 0 138 && JLI_Lseek(fd, pos, SEEK_SET) == pos 139 && read(fd, buf, count) == (jlong) count); 140 } 141 142 143 /* 144 * Tells whether given header values (obtained from either ZIP64 or 145 * non-ZIP64 header) appear to be correct, by checking the first LOC 146 * and CEN headers. 147 */ 148 static jboolean 149 is_valid_end_header(int fd, jlong endpos, 150 jlong censiz, jlong cenoff, jlong entries) { 151 Byte cenhdr[CENHDR]; 152 Byte lochdr[LOCHDR]; 153 // Expected offset of the first central directory header 154 jlong censtart = endpos - censiz; 155 // Expected position within the file that offsets are relative to 156 jlong base_offset = endpos - (censiz + cenoff); 157 return censtart >= 0 && cenoff >= 0 && 158 (censiz == 0 || 159 // Validate first CEN and LOC header signatures. 160 // Central directory must come directly before the end header. 161 (readAt(fd, censtart, CENHDR, cenhdr) 162 && CENSIG_AT(cenhdr) 163 && readAt(fd, base_offset + CENOFF(cenhdr), LOCHDR, lochdr) 164 && LOCSIG_AT(lochdr) 165 && CENNAM(cenhdr) == LOCNAM(lochdr))); 166 } 167 168 /* 169 * Tells whether p appears to be pointing at a valid ZIP64 end header. 170 * Values censiz, cenoff, and entries are the corresponding values 171 * from the non-ZIP64 end header. We perform extra checks to avoid 172 * misidentifying data from the last entry as a ZIP64 end header. 173 */ 174 static jboolean 175 is_zip64_endhdr(int fd, const Byte *p, jlong end64pos, 176 jlong censiz, jlong cenoff, jlong entries) { 177 if (ZIP64_ENDSIG_AT(p)) { 178 jlong censiz64 = ZIP64_ENDSIZ(p); 179 jlong cenoff64 = ZIP64_ENDOFF(p); 180 jlong entries64 = ZIP64_ENDTOT(p); 181 return (censiz64 == censiz || censiz == ZIP64_MAGICVAL) 182 && (cenoff64 == cenoff || cenoff == ZIP64_MAGICVAL) 183 && (entries64 == entries || entries == ZIP64_MAGICCOUNT) 184 && is_valid_end_header(fd, end64pos, censiz64, cenoff64, entries64); 185 } 186 return JNI_FALSE; 187 } 188 189 /* 190 * Given a non-ZIP64 end header located at endhdr and endpos, look for 191 * an adjacent ZIP64 end header, finding the base offset and censtart 192 * from the ZIP64 header if available, else from the non-ZIP64 header. 193 * @return 0 if successful, -1 in case of failure 194 */ 195 static int 196 find_positions64(int fd, const Byte * const endhdr, const jlong endpos, 197 jlong* base_offset, jlong* censtart) 198 { 199 jlong censiz = ENDSIZ(endhdr); 200 jlong cenoff = ENDOFF(endhdr); 201 jlong entries = ENDTOT(endhdr); 202 jlong end64pos; 203 Byte buf[ZIP64_ENDHDR + ZIP64_LOCHDR]; 204 if (censiz + cenoff != endpos 205 && (end64pos = endpos - sizeof(buf)) >= (jlong)0 206 && readAt(fd, end64pos, sizeof(buf), buf) 207 && ZIP64_LOCSIG_AT(buf + ZIP64_ENDHDR) 208 && (jlong) ZIP64_LOCDSK(buf + ZIP64_ENDHDR) == ENDDSK(endhdr) 209 && (is_zip64_endhdr(fd, buf, end64pos, censiz, cenoff, entries) 210 || // A variable sized "zip64 extensible data sector" ? 211 ((end64pos = ZIP64_LOCOFF(buf + ZIP64_ENDHDR)) >= (jlong)0 212 && readAt(fd, end64pos, ZIP64_ENDHDR, buf) 213 && is_zip64_endhdr(fd, buf, end64pos, censiz, cenoff, entries))) 214 ) { 215 *censtart = end64pos - ZIP64_ENDSIZ(buf); 216 *base_offset = *censtart - ZIP64_ENDOFF(buf); 217 } else { 218 if (!is_valid_end_header(fd, endpos, censiz, cenoff, entries)) 219 return -1; 220 *censtart = endpos - censiz; 221 *base_offset = *censtart - cenoff; 222 } 223 return 0; 224 } 225 226 /* 227 * Finds the base offset and censtart of the zip file. 228 * 229 * @param fd file descriptor of the jar file 230 * @param eb scratch buffer 231 * @return 0 if successful, -1 in case of failure 232 */ 233 static int 234 find_positions(int fd, Byte *eb, jlong* base_offset, jlong* censtart) 235 { 236 jlong len; 237 jlong pos; 238 jlong flen; 239 int bytes; 240 Byte *cp; 241 Byte *endpos; 242 Byte *buffer; 243 244 /* 245 * 99.44% (or more) of the time, there will be no comment at the 246 * end of the zip file. Try reading just enough to read the END 247 * record from the end of the file, at this time we should also 248 * check to see if we have a ZIP64 archive. 249 */ 250 if ((pos = JLI_Lseek(fd, -ENDHDR, SEEK_END)) < (jlong)0) 251 return (-1); 252 if (read(fd, eb, ENDHDR) < 0) 253 return (-1); 254 if (ENDSIG_AT(eb)) { 255 return find_positions64(fd, eb, pos, base_offset, censtart); 256 } 257 258 /* 259 * Shucky-Darn,... There is a comment at the end of the zip file. 260 * 261 * Allocate and fill a buffer with enough of the zip file 262 * to meet the specification for a maximal comment length. 263 */ 264 if ((flen = JLI_Lseek(fd, 0, SEEK_END)) < (jlong)0) 265 return (-1); 266 len = (flen < END_MAXLEN) ? flen : END_MAXLEN; 267 if (JLI_Lseek(fd, -len, SEEK_END) < (jlong)0) 268 return (-1); 269 if ((buffer = malloc(END_MAXLEN)) == NULL) 270 return (-1); 271 272 /* 273 * read() on windows takes an unsigned int for count. Casting len 274 * to an unsigned int here is safe since it is guaranteed to be 275 * less than END_MAXLEN. 276 */ 277 if ((bytes = read(fd, buffer, (unsigned int)len)) < 0) { 278 free(buffer); 279 return (-1); 280 } 281 282 /* 283 * Search backwards from the end of file stopping when the END header 284 * signature is found. 285 */ 286 endpos = &buffer[bytes]; 287 for (cp = &buffer[bytes - ENDHDR]; cp >= &buffer[0]; cp--) 288 if (ENDSIG_AT(cp) && (cp + ENDHDR + ENDCOM(cp) == endpos)) { 289 (void) memcpy(eb, cp, ENDHDR); 290 free(buffer); 291 pos = flen - (endpos - cp); 292 return find_positions64(fd, eb, pos, base_offset, censtart); 293 } 294 free(buffer); 295 return (-1); 296 } 297 298 #define BUFSIZE (3 * 65536 + CENHDR + SIGSIZ) 299 #define MINREAD 1024 300 301 /* 302 * Locate the manifest file with the zip/jar file. 303 * 304 * fd: File descriptor of the jar file. 305 * entry: To be populated with the information necessary to perform 306 * the inflation (the compressed and uncompressed sizes and 307 * the offset in the file where the compressed data is located). 308 * 309 * Returns zero upon success. Returns a negative value upon failure. 310 * 311 * The buffer for reading the Central Directory if the zip/jar file needs 312 * to be large enough to accommodate the largest possible single record 313 * and the signature of the next record which is: 314 * 315 * 3*2**16 + CENHDR + SIGSIZ 316 * 317 * Each of the three variable sized fields (name, comment and extension) 318 * has a maximum possible size of 64k. 319 * 320 * Typically, only a small bit of this buffer is used with bytes shuffled 321 * down to the beginning of the buffer. It is one thing to allocate such 322 * a large buffer and another thing to actually start faulting it in. 323 * 324 * In most cases, all that needs to be read are the first two entries in 325 * a typical jar file (META-INF and META-INF/MANIFEST.MF). Keep this factoid 326 * in mind when optimizing this code. 327 */ 328 static int 329 find_file(int fd, zentry *entry, const char *file_name) 330 { 331 int bytes; 332 int res; 333 int entry_size; 334 int read_size; 335 336 /* 337 * The (imaginary) position within the file relative to which 338 * offsets within the zip file refer. This is usually the 339 * location of the first local header (the start of the zip data) 340 * (which in turn is usually 0), but if the zip file has content 341 * prepended, then it will be either 0 or the length of the 342 * prepended content, depending on whether or not internal offsets 343 * have been adjusted (via e.g. zip -A). May be negative if 344 * content is prepended, zip -A is run, then the prefix is 345 * detached! 346 */ 347 jlong base_offset; 348 349 /** The position within the file of the start of the central directory. */ 350 jlong censtart; 351 352 Byte *p; 353 Byte *bp; 354 Byte *buffer; 355 Byte locbuf[LOCHDR]; 356 357 if ((buffer = (Byte*)malloc(BUFSIZE)) == NULL) { 358 return(-1); 359 } 360 361 bp = buffer; 362 363 if (find_positions(fd, bp, &base_offset, &censtart) == -1) { 364 return -1; 365 } 366 if (JLI_Lseek(fd, censtart, SEEK_SET) < (jlong) 0) { 367 return -1; 368 } 369 370 if ((bytes = read(fd, bp, MINREAD)) < 0) { 371 free(buffer); 372 return (-1); 373 } 374 p = bp; 375 /* 376 * Loop through the Central Directory Headers. Note that a valid zip/jar 377 * must have an ENDHDR (with ENDSIG) after the Central Directory. 378 */ 379 while (CENSIG_AT(p)) { 380 381 /* 382 * If a complete header isn't in the buffer, shift the contents 383 * of the buffer down and refill the buffer. Note that the check 384 * for "bytes < CENHDR" must be made before the test for the entire 385 * size of the header, because if bytes is less than CENHDR, the 386 * actual size of the header can't be determined. The addition of 387 * SIGSIZ guarantees that the next signature is also in the buffer 388 * for proper loop termination. 389 */ 390 if (bytes < CENHDR) { 391 p = memmove(bp, p, bytes); 392 if ((res = read(fd, bp + bytes, MINREAD)) <= 0) { 393 free(buffer); 394 return (-1); 395 } 396 bytes += res; 397 } 398 entry_size = CENHDR + CENNAM(p) + CENEXT(p) + CENCOM(p); 399 if (bytes < entry_size + SIGSIZ) { 400 if (p != bp) 401 p = memmove(bp, p, bytes); 402 read_size = entry_size - bytes + SIGSIZ; 403 read_size = (read_size < MINREAD) ? MINREAD : read_size; 404 if ((res = read(fd, bp + bytes, read_size)) <= 0) { 405 free(buffer); 406 return (-1); 407 } 408 bytes += res; 409 } 410 411 /* 412 * Check if the name is the droid we are looking for; the jar file 413 * manifest. If so, build the entry record from the data found in 414 * the header located and return success. 415 */ 416 if ((size_t)CENNAM(p) == JLI_StrLen(file_name) && 417 memcmp((p + CENHDR), file_name, JLI_StrLen(file_name)) == 0) { 418 if (JLI_Lseek(fd, base_offset + CENOFF(p), SEEK_SET) < (jlong)0) { 419 free(buffer); 420 return (-1); 421 } 422 if (read(fd, locbuf, LOCHDR) < 0) { 423 free(buffer); 424 return (-1); 425 } 426 if (!LOCSIG_AT(locbuf)) { 427 free(buffer); 428 return (-1); 429 } 430 entry->isize = CENLEN(p); 431 entry->csize = CENSIZ(p); 432 entry->offset = base_offset + CENOFF(p) + LOCHDR + 433 LOCNAM(locbuf) + LOCEXT(locbuf); 434 entry->how = CENHOW(p); 435 free(buffer); 436 return (0); 437 } 438 439 /* 440 * Point to the next entry and decrement the count of valid remaining 441 * bytes. 442 */ 443 bytes -= entry_size; 444 p += entry_size; 445 } 446 free(buffer); 447 return (-1); /* Fell off the end the loop without a Manifest */ 448 } 449 450 /* 451 * Parse a Manifest file header entry into a distinct "name" and "value". 452 * Continuation lines are joined into a single "value". The documented 453 * syntax for a header entry is: 454 * 455 * header: name ":" value 456 * 457 * name: alphanum *headerchar 458 * 459 * value: SPACE *otherchar newline *continuation 460 * 461 * continuation: SPACE *otherchar newline 462 * 463 * newline: CR LF | LF | CR (not followed by LF) 464 * 465 * alphanum: {"A"-"Z"} | {"a"-"z"} | {"0"-"9"} 466 * 467 * headerchar: alphanum | "-" | "_" 468 * 469 * otherchar: any UTF-8 character except NUL, CR and LF 470 * 471 * Note that a manifest file may be composed of multiple sections, 472 * each of which may contain multiple headers. 473 * 474 * section: *header +newline 475 * 476 * nonempty-section: +header +newline 477 * 478 * (Note that the point of "nonempty-section" is unclear, because it isn't 479 * referenced elsewhere in the full specification for the Manifest file.) 480 * 481 * Arguments: 482 * lp pointer to a character pointer which points to the start 483 * of a valid header. 484 * name pointer to a character pointer which will be set to point 485 * to the name portion of the header (nul terminated). 486 * value pointer to a character pointer which will be set to point 487 * to the value portion of the header (nul terminated). 488 * 489 * Returns: 490 * 1 Successful parsing of an NV pair. lp is updated to point to the 491 * next character after the terminating newline in the string 492 * representing the Manifest file. name and value are updated to 493 * point to the strings parsed. 494 * 0 A valid end of section indicator was encountered. lp, name, and 495 * value are not modified. 496 * -1 lp does not point to a valid header. Upon return, the values of 497 * lp, name, and value are undefined. 498 */ 499 static int 500 parse_nv_pair(char **lp, char **name, char **value) 501 { 502 char *nl; 503 char *cp; 504 505 /* 506 * End of the section - return 0. The end of section condition is 507 * indicated by either encountering a blank line or the end of the 508 * Manifest "string" (EOF). 509 */ 510 if (**lp == '\0' || **lp == '\n' || **lp == '\r') 511 return (0); 512 513 /* 514 * Getting to here, indicates that *lp points to an "otherchar". 515 * Turn the "header" into a string on its own. 516 */ 517 nl = JLI_StrPBrk(*lp, "\n\r"); 518 if (nl == NULL) { 519 nl = JLI_StrChr(*lp, (int)'\0'); 520 } else { 521 cp = nl; /* For merging continuation lines */ 522 if (*nl == '\r' && *(nl+1) == '\n') 523 *nl++ = '\0'; 524 *nl++ = '\0'; 525 526 /* 527 * Process any "continuation" line(s), by making them part of the 528 * "header" line. Yes, I know that we are "undoing" the NULs we 529 * just placed here, but continuation lines are the fairly rare 530 * case, so we shouldn't unnecessarily complicate the code above. 531 * 532 * Note that an entire continuation line is processed each iteration 533 * through the outer while loop. 534 */ 535 while (*nl == ' ') { 536 nl++; /* First character to be moved */ 537 while (*nl != '\n' && *nl != '\r' && *nl != '\0') 538 *cp++ = *nl++; /* Shift string */ 539 if (*nl == '\0') 540 return (-1); /* Error: newline required */ 541 *cp = '\0'; 542 if (*nl == '\r' && *(nl+1) == '\n') 543 *nl++ = '\0'; 544 *nl++ = '\0'; 545 } 546 } 547 548 /* 549 * Separate the name from the value; 550 */ 551 cp = JLI_StrChr(*lp, (int)':'); 552 if (cp == NULL) 553 return (-1); 554 *cp++ = '\0'; /* The colon terminates the name */ 555 if (*cp != ' ') 556 return (-1); 557 *cp++ = '\0'; /* Eat the required space */ 558 *name = *lp; 559 *value = cp; 560 *lp = nl; 561 return (1); 562 } 563 564 /* 565 * Read the manifest from the specified jar file and fill in the manifest_info 566 * structure with the information found within. 567 * 568 * Error returns are as follows: 569 * 0 Success 570 * -1 Unable to open jarfile 571 * -2 Error accessing the manifest from within the jarfile (most likely 572 * a manifest is not present, or this isn't a valid zip/jar file). 573 */ 574 int 575 JLI_ParseManifest(char *jarfile, manifest_info *info) 576 { 577 int fd; 578 zentry entry; 579 char *lp; 580 char *name; 581 char *value; 582 int rc; 583 char *splashscreen_name = NULL; 584 585 if ((fd = open(jarfile, O_RDONLY 586 #ifdef O_LARGEFILE 587 | O_LARGEFILE /* large file mode */ 588 #endif 589 #ifdef O_BINARY 590 | O_BINARY /* use binary mode on windows */ 591 #endif 592 )) == -1) { 593 return (-1); 594 } 595 info->manifest_version = NULL; 596 info->main_class = NULL; 597 info->jre_version = NULL; 598 info->jre_restrict_search = 0; 599 info->splashscreen_image_file_name = NULL; 600 if ((rc = find_file(fd, &entry, manifest_name)) != 0) { 601 close(fd); 602 return (-2); 603 } 604 manifest = inflate_file(fd, &entry, NULL); 605 if (manifest == NULL) { 606 close(fd); 607 return (-2); 608 } 609 lp = manifest; 610 while ((rc = parse_nv_pair(&lp, &name, &value)) > 0) { 611 if (JLI_StrCaseCmp(name, "Manifest-Version") == 0) { 612 info->manifest_version = value; 613 } else if (JLI_StrCaseCmp(name, "Main-Class") == 0) { 614 info->main_class = value; 615 } else if (JLI_StrCaseCmp(name, "JRE-Version") == 0) { 616 /* 617 * Manifest specification overridden by command line option 618 * so we will silently override there with no specification. 619 */ 620 info->jre_version = 0; 621 } else if (JLI_StrCaseCmp(name, "Splashscreen-Image") == 0) { 622 info->splashscreen_image_file_name = value; 623 } 624 } 625 close(fd); 626 if (rc == 0) 627 return (0); 628 else 629 return (-2); 630 } 631 632 /* 633 * Opens the jar file and unpacks the specified file from its contents. 634 * Returns NULL on failure. 635 */ 636 void * 637 JLI_JarUnpackFile(const char *jarfile, const char *filename, int *size) { 638 int fd; 639 zentry entry; 640 void *data = NULL; 641 642 if ((fd = open(jarfile, O_RDONLY 643 #ifdef O_LARGEFILE 644 | O_LARGEFILE /* large file mode */ 645 #endif 646 #ifdef O_BINARY 647 | O_BINARY /* use binary mode on windows */ 648 #endif 649 )) == -1) { 650 return NULL; 651 } 652 if (find_file(fd, &entry, filename) == 0) { 653 data = inflate_file(fd, &entry, size); 654 } 655 close(fd); 656 return (data); 657 } 658 659 /* 660 * Specialized "free" function. 661 */ 662 void 663 JLI_FreeManifest() 664 { 665 if (manifest) 666 free(manifest); 667 } 668 669 /* 670 * Iterate over the manifest of the specified jar file and invoke the provided 671 * closure function for each attribute encountered. 672 * 673 * Error returns are as follows: 674 * 0 Success 675 * -1 Unable to open jarfile 676 * -2 Error accessing the manifest from within the jarfile (most likely 677 * this means a manifest is not present, or it isn't a valid zip/jar file). 678 */ 679 int 680 JLI_ManifestIterate(const char *jarfile, attribute_closure ac, void *user_data) 681 { 682 int fd; 683 zentry entry; 684 char *mp; /* manifest pointer */ 685 char *lp; /* pointer into manifest, updated during iteration */ 686 char *name; 687 char *value; 688 int rc; 689 690 if ((fd = open(jarfile, O_RDONLY 691 #ifdef O_LARGEFILE 692 | O_LARGEFILE /* large file mode */ 693 #endif 694 #ifdef O_BINARY 695 | O_BINARY /* use binary mode on windows */ 696 #endif 697 )) == -1) { 698 return (-1); 699 } 700 701 if ((rc = find_file(fd, &entry, manifest_name)) != 0) { 702 close(fd); 703 return (-2); 704 } 705 706 mp = inflate_file(fd, &entry, NULL); 707 if (mp == NULL) { 708 close(fd); 709 return (-2); 710 } 711 712 lp = mp; 713 while ((rc = parse_nv_pair(&lp, &name, &value)) > 0) { 714 (*ac)(name, value, user_data); 715 } 716 free(mp); 717 close(fd); 718 return (rc == 0) ? 0 : -2; 719 }