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_FINISH) != Z_STREAM_END) {
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 }