xref: /illumos-gate/usr/src/boot/lib/libstand/pkgfs.c (revision 199767f8)
1 /*-
2  * Copyright (c) 2007-2014, Juniper Networks, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include "stand.h"
31 
32 #include <sys/stat.h>
33 #include <sys/stdint.h>
34 #include <string.h>
35 #include <zlib.h>
36 
37 #ifdef PKGFS_DEBUG
38 #define	DBG(x)	printf x
39 #else
40 #define	DBG(x)
41 #endif
42 
43 static int   pkg_open(const char *, struct open_file *);
44 static int   pkg_close(struct open_file *);
45 static int   pkg_read(struct open_file *, void *, size_t, size_t *);
46 static off_t pkg_seek(struct open_file *, off_t, int);
47 static int   pkg_stat(struct open_file *, struct stat *);
48 static int   pkg_readdir(struct open_file *, struct dirent *);
49 
50 struct fs_ops pkgfs_fsops = {
51 	"pkg",
52 	pkg_open,
53 	pkg_close,
54 	pkg_read,
55 	null_write,
56 	pkg_seek,
57 	pkg_stat,
58 	pkg_readdir
59 };
60 
61 #define PKG_BUFSIZE	512
62 #define	PKG_MAXCACHESZ	4096
63 
64 #define	PKG_FILEEXT	".tgz"
65 
66 /*
67  * Layout of POSIX 'ustar' header.
68  */
69 struct ustar_hdr {
70 	char	ut_name[100];
71 	char	ut_mode[8];
72 	char	ut_uid[8];
73 	char	ut_gid[8];
74 	char	ut_size[12];
75 	char	ut_mtime[12];
76 	char	ut_checksum[8];
77 	char	ut_typeflag[1];
78 	char	ut_linkname[100];
79 	char	ut_magic[6];		/* For POSIX: "ustar\0" */
80 	char	ut_version[2];		/* For POSIX: "00" */
81 	char	ut_uname[32];
82 	char	ut_gname[32];
83 	char	ut_rdevmajor[8];
84 	char	ut_rdevminor[8];
85 	union {
86 		struct {
87 			char	prefix[155];
88 		} posix;
89 		struct {
90 			char	atime[12];
91 			char	ctime[12];
92 			char	offset[12];
93 			char	longnames[4];
94 			char	unused[1];
95 			struct gnu_sparse {
96 				char	offset[12];
97 				char	numbytes[12];
98 			} sparse[4];
99 			char	isextended[1];
100 			char	realsize[12];
101 		} gnu;
102 	} u;
103 	u_char __padding[12];
104 };
105 
106 struct package;
107 
108 struct tarfile
109 {
110 	struct package *tf_pkg;
111 	struct tarfile *tf_next;
112 	struct ustar_hdr tf_hdr;
113 	off_t	tf_ofs;
114 	off_t	tf_size;
115 	off_t	tf_fp;
116 	size_t	tf_cachesz;
117 	void	*tf_cache;
118 };
119 
120 struct package
121 {
122 	struct package *pkg_chain;
123 	int	pkg_fd;
124 	off_t	pkg_ofs;
125 	z_stream pkg_zs;
126 	struct tarfile *pkg_first;
127 	struct tarfile *pkg_last;
128 	u_char	pkg_buf[PKG_BUFSIZE];
129 };
130 
131 static struct package *package = NULL;
132 
133 static int new_package(int, struct package **);
134 
135 void
pkgfs_cleanup(void)136 pkgfs_cleanup(void)
137 {
138 	struct package *chain;
139 	struct tarfile *tf, *tfn;
140 
141 	while (package != NULL) {
142 		inflateEnd(&package->pkg_zs);
143 		close(package->pkg_fd);
144 
145 		tf = package->pkg_first;
146 		while (tf != NULL) {
147 			tfn = tf->tf_next;
148 			if (tf->tf_cachesz > 0)
149 				free(tf->tf_cache);
150 			free(tf);
151 			tf = tfn;
152 		}
153 
154 		chain = package->pkg_chain;
155 		free(package);
156 		package = chain;
157 	}
158 }
159 
160 int
pkgfs_init(const char * pkgname,struct fs_ops * proto)161 pkgfs_init(const char *pkgname, struct fs_ops *proto)
162 {
163 	struct package *pkg;
164 	int error, fd;
165 
166 	if (proto != &pkgfs_fsops)
167 		pkgfs_cleanup();
168 
169 	exclusive_file_system = proto;
170 
171 	fd = open(pkgname, O_RDONLY);
172 
173 	exclusive_file_system = NULL;
174 
175 	if (fd == -1)
176 		return (errno);
177 
178 	error = new_package(fd, &pkg);
179 	if (error) {
180 		close(fd);
181 		return (error);
182 	}
183 
184 	if (pkg == NULL)
185 		return (EDOOFUS);
186 
187 	pkg->pkg_chain = package;
188 	package = pkg;
189 	exclusive_file_system = &pkgfs_fsops;
190 	return (0);
191 }
192 
193 static int get_mode(struct tarfile *);
194 static int get_zipped(struct package *, void *, size_t);
195 static int new_package(int, struct package **);
196 static struct tarfile *scan_tarfile(struct package *, struct tarfile *);
197 
198 static int
pkg_open(const char * fn,struct open_file * f)199 pkg_open(const char *fn, struct open_file *f)
200 {
201 	struct tarfile *tf;
202 
203 	if (fn == NULL || f == NULL)
204 		return (EINVAL);
205 
206 	if (package == NULL)
207 		return (ENXIO);
208 
209 	/*
210 	 * We can only read from a package, so reject request to open
211 	 * for write-only or read-write.
212 	 */
213 	if (f->f_flags != F_READ)
214 		return (EPERM);
215 
216 	/*
217 	 * Scan the file headers for the named file. We stop scanning
218 	 * at the first filename that has the .pkg extension. This is
219 	 * a package within a package. We assume we have all the files
220 	 * we need up-front and without having to dig within nested
221 	 * packages.
222 	 *
223 	 * Note that we preserve streaming properties as much as possible.
224 	 */
225 	while (*fn == '/')
226 		fn++;
227 
228 	/*
229 	 * Allow opening of the root directory for use by readdir()
230 	 * to support listing files in the package.
231 	 */
232 	if (*fn == '\0') {
233 		f->f_fsdata = NULL;
234 		return (0);
235 	}
236 
237 	tf = scan_tarfile(package, NULL);
238 	while (tf != NULL) {
239 		if (strcmp(fn, tf->tf_hdr.ut_name) == 0) {
240 			f->f_fsdata = tf;
241 			tf->tf_fp = 0;	/* Reset the file pointer. */
242 			return (0);
243 		}
244 		tf = scan_tarfile(package, tf);
245 	}
246 	return (errno);
247 }
248 
249 static int
pkg_close(struct open_file * f)250 pkg_close(struct open_file *f)
251 {
252 	struct tarfile *tf;
253 
254 	tf = (struct tarfile *)f->f_fsdata;
255 	if (tf == NULL)
256 		return (0);
257 
258 	/*
259 	 * Free up the cache if we read all of the file.
260 	 */
261 	if (tf->tf_fp == tf->tf_size && tf->tf_cachesz > 0) {
262 		free(tf->tf_cache);
263 		tf->tf_cachesz = 0;
264 	}
265 	return (0);
266 }
267 
268 static int
pkg_read(struct open_file * f,void * buf,size_t size,size_t * res)269 pkg_read(struct open_file *f, void *buf, size_t size, size_t *res)
270 {
271 	struct tarfile *tf;
272 	char *p;
273 	off_t fp;
274 	size_t sz;
275 
276 	tf = (struct tarfile *)f->f_fsdata;
277 	if (tf == NULL) {
278 		if (res != NULL)
279 			*res = size;
280 		return (EBADF);
281 	}
282 
283 	fp = tf->tf_fp;
284 	p = buf;
285 	sz = 0;
286 	while (size > 0) {
287 		sz = tf->tf_size - fp;
288 		if (fp < tf->tf_cachesz && tf->tf_cachesz < tf->tf_size)
289 			sz = tf->tf_cachesz - fp;
290 		if (size < sz)
291 			sz = size;
292 		if (sz == 0)
293 			break;
294 
295 		if (fp < tf->tf_cachesz) {
296 			/* Satisfy the request from cache. */
297 			memcpy(p, tf->tf_cache + fp, sz);
298 			fp += sz;
299 			p += sz;
300 			size -= sz;
301 			continue;
302 		}
303 
304 		if (get_zipped(tf->tf_pkg, p, sz) == -1) {
305 			sz = -1;
306 			break;
307 		}
308 
309 		fp += sz;
310 		p += sz;
311 		size -= sz;
312 
313 		if (tf->tf_cachesz != 0)
314 			continue;
315 
316 		tf->tf_cachesz = (sz <= PKG_MAXCACHESZ) ? sz : PKG_MAXCACHESZ;
317 		tf->tf_cache = malloc(tf->tf_cachesz);
318 		if (tf->tf_cache != NULL)
319 			memcpy(tf->tf_cache, buf, tf->tf_cachesz);
320 		else
321 			tf->tf_cachesz = 0;
322 	}
323 
324 	tf->tf_fp = fp;
325 	if (res != NULL)
326 		*res = size;
327 	return ((sz == -1) ? errno : 0);
328 }
329 
330 static off_t
pkg_seek(struct open_file * f,off_t ofs,int whence)331 pkg_seek(struct open_file *f, off_t ofs, int whence)
332 {
333 	char buf[512];
334 	struct tarfile *tf;
335 	off_t delta;
336 	size_t sz, res;
337 	int error;
338 
339 	tf = (struct tarfile *)f->f_fsdata;
340 	if (tf == NULL) {
341 		errno = EBADF;
342 		return (-1);
343 	}
344 
345 	switch (whence) {
346 	case SEEK_SET:
347 		delta = ofs - tf->tf_fp;
348 		break;
349 	case SEEK_CUR:
350 		delta = ofs;
351 		break;
352 	case SEEK_END:
353 		delta = tf->tf_size - tf->tf_fp + ofs;
354 		break;
355 	default:
356 		errno = EINVAL;
357 		return (-1);
358 	}
359 
360 	if (delta < 0) {
361 		DBG(("%s: negative file seek (%jd)\n", __func__,
362 		    (intmax_t)delta));
363 		errno = ESPIPE;
364 		return (-1);
365 	}
366 
367 	while (delta > 0 && tf->tf_fp < tf->tf_size) {
368 		sz = (delta > sizeof(buf)) ? sizeof(buf) : delta;
369 		error = pkg_read(f, buf, sz, &res);
370 		if (error != 0) {
371 			errno = error;
372 			return (-1);
373 		}
374 		delta -= sz - res;
375 	}
376 
377 	return (tf->tf_fp);
378 }
379 
380 static int
pkg_stat(struct open_file * f,struct stat * sb)381 pkg_stat(struct open_file *f, struct stat *sb)
382 {
383 	struct tarfile *tf;
384 
385 	tf = (struct tarfile *)f->f_fsdata;
386 	if (tf == NULL)
387 		return (EBADF);
388 	memset(sb, 0, sizeof(*sb));
389 	sb->st_mode = get_mode(tf);
390 	sb->st_size = tf->tf_size;
391 	sb->st_blocks = (tf->tf_size + 511) / 512;
392 	return (0);
393 }
394 
395 static int
pkg_readdir(struct open_file * f,struct dirent * d)396 pkg_readdir(struct open_file *f, struct dirent *d)
397 {
398 	struct tarfile *tf;
399 
400 	tf = (struct tarfile *)f->f_fsdata;
401 	if (tf != NULL)
402 		return (EBADF);
403 
404 	tf = scan_tarfile(package, NULL);
405 	if (tf == NULL)
406 		return (ENOENT);
407 
408 	d->d_fileno = 0;
409 	d->d_reclen = sizeof(*d);
410 	d->d_type = DT_REG;
411 	memcpy(d->d_name, tf->tf_hdr.ut_name, sizeof(d->d_name));
412 	return (0);
413 }
414 
415 /*
416  * Low-level support functions.
417  */
418 
419 static int
get_byte(struct package * pkg,off_t * op)420 get_byte(struct package *pkg, off_t *op)
421 {
422 	int c;
423 
424 	if (pkg->pkg_zs.avail_in == 0) {
425 		c = read(pkg->pkg_fd, pkg->pkg_buf, PKG_BUFSIZE);
426 		if (c <= 0)
427 			return (-1);
428 		pkg->pkg_zs.avail_in = c;
429 		pkg->pkg_zs.next_in = pkg->pkg_buf;
430 	}
431 
432 	c = *pkg->pkg_zs.next_in;
433 	pkg->pkg_zs.next_in++;
434 	pkg->pkg_zs.avail_in--;
435 	(*op)++;
436 	return (c);
437 }
438 
439 static int
get_zipped(struct package * pkg,void * buf,size_t bufsz)440 get_zipped(struct package *pkg, void *buf, size_t bufsz)
441 {
442 	int c;
443 
444 	pkg->pkg_zs.next_out = buf;
445 	pkg->pkg_zs.avail_out = bufsz;
446 
447 	while (pkg->pkg_zs.avail_out) {
448 		if (pkg->pkg_zs.avail_in == 0) {
449 			c = read(pkg->pkg_fd, pkg->pkg_buf, PKG_BUFSIZE);
450 			if (c <= 0) {
451 				errno = EIO;
452 				return (-1);
453 			}
454 			pkg->pkg_zs.avail_in = c;
455 			pkg->pkg_zs.next_in = pkg->pkg_buf;
456 		}
457 
458 		c = inflate(&pkg->pkg_zs, Z_SYNC_FLUSH);
459 		if (c != Z_OK && c != Z_STREAM_END) {
460 			errno = EIO;
461 			return (-1);
462 		}
463 	}
464 
465 	pkg->pkg_ofs += bufsz;
466 	return (0);
467 }
468 
469 static int
cache_data(struct tarfile * tf)470 cache_data(struct tarfile *tf)
471 {
472 	struct package *pkg;
473 	size_t sz;
474 
475 	if (tf == NULL) {
476 		DBG(("%s: no file to cache data for?\n", __func__));
477 		errno = EINVAL;
478 		return (-1);
479 	}
480 
481 	pkg = tf->tf_pkg;
482 	if (pkg == NULL) {
483 		DBG(("%s: no package associated with file?\n", __func__));
484 		errno = EINVAL;
485 		return (-1);
486 	}
487 
488 	if (tf->tf_ofs != pkg->pkg_ofs) {
489 		DBG(("%s: caching after partial read of file %s?\n",
490 		    __func__, tf->tf_hdr.ut_name));
491 		errno = EINVAL;
492 		return (-1);
493 	}
494 
495 	/* We don't cache everything... */
496 	if (tf->tf_size > PKG_MAXCACHESZ) {
497 		errno = ENOMEM;
498 		return (-1);
499 	}
500 
501 	/* All files are padded to a multiple of 512 bytes. */
502 	sz = (tf->tf_size + 0x1ff) & ~0x1ff;
503 
504 	tf->tf_cache = malloc(sz);
505 	if (tf->tf_cache == NULL) {
506 		DBG(("%s: could not allocate %d bytes\n", __func__, (int)sz));
507 		errno = ENOMEM;
508 		return (-1);
509 	}
510 
511 	tf->tf_cachesz = sz;
512 	return (get_zipped(pkg, tf->tf_cache, sz));
513 }
514 
515 /*
516  * Note that this implementation does not (and should not!) obey
517  * locale settings; you cannot simply substitute strtol here, since
518  * it does obey locale.
519  */
520 static off_t
pkg_atol8(const char * p,unsigned char_cnt)521 pkg_atol8(const char *p, unsigned char_cnt)
522 {
523         int64_t l, limit, last_digit_limit;
524         int digit, sign, base;
525 
526         base = 8;
527         limit = INT64_MAX / base;
528         last_digit_limit = INT64_MAX % base;
529 
530         while (*p == ' ' || *p == '\t')
531                 p++;
532         if (*p == '-') {
533                 sign = -1;
534                 p++;
535         } else
536                 sign = 1;
537 
538         l = 0;
539         digit = *p - '0';
540         while (digit >= 0 && digit < base  && char_cnt-- > 0) {
541                 if (l>limit || (l == limit && digit > last_digit_limit)) {
542                         l = UINT64_MAX; /* Truncate on overflow. */
543                         break;
544                 }
545                 l = (l * base) + digit;
546                 digit = *++p - '0';
547         }
548         return (sign < 0) ? -l : l;
549 }
550 
551 /*
552  * Parse a base-256 integer.  This is just a straight signed binary
553  * value in big-endian order, except that the high-order bit is
554  * ignored.  Remember that "int64_t" may or may not be exactly 64
555  * bits; the implementation here tries to avoid making any assumptions
556  * about the actual size of an int64_t.  It does assume we're using
557  * twos-complement arithmetic, though.
558  */
559 static int64_t
pkg_atol256(const char * _p,unsigned char_cnt)560 pkg_atol256(const char *_p, unsigned char_cnt)
561 {
562         int64_t l, upper_limit, lower_limit;
563         const unsigned char *p = (const unsigned char *)_p;
564 
565         upper_limit = INT64_MAX / 256;
566         lower_limit = INT64_MIN / 256;
567 
568         /* Pad with 1 or 0 bits, depending on sign. */
569         if ((0x40 & *p) == 0x40)
570                 l = (int64_t)-1;
571         else
572                 l = 0;
573         l = (l << 6) | (0x3f & *p++);
574         while (--char_cnt > 0) {
575                 if (l > upper_limit) {
576                         l = INT64_MAX; /* Truncate on overflow */
577                         break;
578                 } else if (l < lower_limit) {
579                         l = INT64_MIN;
580                         break;
581                 }
582                 l = (l << 8) | (0xff & (int64_t)*p++);
583         }
584         return (l);
585 }
586 
587 static off_t
pkg_atol(const char * p,unsigned char_cnt)588 pkg_atol(const char *p, unsigned char_cnt)
589 {
590 	/*
591 	 * Technically, GNU pkg considers a field to be in base-256
592 	 * only if the first byte is 0xff or 0x80.
593 	 */
594 	if (*p & 0x80)
595 		return (pkg_atol256(p, char_cnt));
596 	return (pkg_atol8(p, char_cnt));
597 }
598 
599 static int
get_mode(struct tarfile * tf)600 get_mode(struct tarfile *tf)
601 {
602 	return (pkg_atol(tf->tf_hdr.ut_mode, sizeof(tf->tf_hdr.ut_mode)));
603 }
604 
605 /* GZip flag byte */
606 #define ASCII_FLAG	0x01 /* bit 0 set: file probably ascii text */
607 #define HEAD_CRC	0x02 /* bit 1 set: header CRC present */
608 #define EXTRA_FIELD	0x04 /* bit 2 set: extra field present */
609 #define ORIG_NAME	0x08 /* bit 3 set: original file name present */
610 #define COMMENT		0x10 /* bit 4 set: file comment present */
611 #define RESERVED	0xE0 /* bits 5..7: reserved */
612 
613 static int
new_package(int fd,struct package ** pp)614 new_package(int fd, struct package **pp)
615 {
616 	struct package *pkg;
617 	off_t ofs;
618 	int flags, i, error;
619 
620 	pkg = malloc(sizeof(*pkg));
621 	if (pkg == NULL)
622 		return (ENOMEM);
623 
624 	bzero(pkg, sizeof(*pkg));
625 	pkg->pkg_fd = fd;
626 
627 	/*
628 	 * Parse the header.
629 	 */
630 	error = EFTYPE;
631 	ofs = 0;
632 
633 	/* Check megic. */
634 	if (get_byte(pkg, &ofs) != 0x1f || get_byte(pkg, &ofs) != 0x8b)
635 		goto fail;
636 	/* Check method. */
637 	if (get_byte(pkg, &ofs) != Z_DEFLATED)
638 		goto fail;
639 	/* Check flags. */
640 	flags = get_byte(pkg, &ofs);
641 	if (flags & RESERVED)
642 		goto fail;
643 
644 	/* Skip time, xflags and OS code. */
645 	for (i = 0; i < 6; i++) {
646 		if (get_byte(pkg, &ofs) == -1)
647 			goto fail;
648 	}
649 
650 	/* Skip extra field. */
651 	if (flags & EXTRA_FIELD) {
652 		i = (get_byte(pkg, &ofs) & 0xff) |
653 		    ((get_byte(pkg, &ofs) << 8) & 0xff);
654 		while (i-- > 0) {
655 			if (get_byte(pkg, &ofs) == -1)
656 				goto fail;
657 		}
658 	}
659 
660 	/* Skip original file name. */
661 	if (flags & ORIG_NAME) {
662 		do {
663 			i = get_byte(pkg, &ofs);
664 		} while (i != 0 && i != -1);
665 		if (i == -1)
666 			goto fail;
667 	}
668 
669 	/* Print the comment if it's there. */
670 	if (flags & COMMENT) {
671 		while (1) {
672 			i = get_byte(pkg, &ofs);
673 			if (i == -1)
674 				goto fail;
675 			if (i == 0)
676 				break;
677 			putchar(i);
678 		}
679 	}
680 
681 	/* Skip the CRC. */
682 	if (flags & HEAD_CRC) {
683 		if (get_byte(pkg, &ofs) == -1)
684 			goto fail;
685 		if (get_byte(pkg, &ofs) == -1)
686 			goto fail;
687 	}
688 
689 	/*
690 	 * Done parsing the ZIP header. Spkgt the inflation engine.
691 	 */
692 	error = inflateInit2(&pkg->pkg_zs, -15);
693 	if (error != Z_OK)
694 		goto fail;
695 
696 	*pp = pkg;
697 	return (0);
698 
699  fail:
700 	free(pkg);
701 	return (error);
702 }
703 
704 static struct tarfile *
scan_tarfile(struct package * pkg,struct tarfile * last)705 scan_tarfile(struct package *pkg, struct tarfile *last)
706 {
707 	char buf[512];
708 	struct tarfile *cur;
709 	off_t ofs;
710 	size_t sz;
711 
712 	cur = (last != NULL) ? last->tf_next : pkg->pkg_first;
713 	if (cur == NULL) {
714 		ofs = (last != NULL) ? last->tf_ofs + last->tf_size :
715 		    pkg->pkg_ofs;
716 		ofs = (ofs + 0x1ff) & ~0x1ff;
717 
718 		/* Check if we've reached EOF. */
719 		if (ofs < pkg->pkg_ofs) {
720 			errno = ENOSPC;
721 			return (NULL);
722 		}
723 
724 		if (ofs != pkg->pkg_ofs) {
725 			if (last != NULL && pkg->pkg_ofs == last->tf_ofs) {
726 				if (cache_data(last) == -1)
727 					return (NULL);
728 			} else {
729 				sz = ofs - pkg->pkg_ofs;
730 				while (sz != 0) {
731 					if (sz > sizeof(buf))
732 						sz = sizeof(buf);
733 					if (get_zipped(pkg, buf, sz) == -1)
734 						return (NULL);
735 					sz = ofs - pkg->pkg_ofs;
736 				}
737 			}
738 		}
739 
740 		cur = malloc(sizeof(*cur));
741 		if (cur == NULL)
742 			return (NULL);
743 		memset(cur, 0, sizeof(*cur));
744 		cur->tf_pkg = pkg;
745 
746 		while (1) {
747 			if (get_zipped(pkg, &cur->tf_hdr,
748 			    sizeof(cur->tf_hdr)) == -1) {
749 				free(cur);
750 				return (NULL);
751 			}
752 
753 			/*
754 			 * There are always 2 empty blocks appended to
755 			 * a PKG. It marks the end of the archive.
756 			 */
757 			if (strncmp(cur->tf_hdr.ut_magic, "ustar", 5) != 0) {
758 				free(cur);
759 				errno = ENOSPC;
760 				return (NULL);
761 			}
762 
763 			cur->tf_ofs = pkg->pkg_ofs;
764 			cur->tf_size = pkg_atol(cur->tf_hdr.ut_size,
765 			    sizeof(cur->tf_hdr.ut_size));
766 
767 			if (cur->tf_hdr.ut_name[0] != '+')
768 				break;
769 
770 			/*
771 			 * Skip package meta-files.
772 			 */
773 			ofs = cur->tf_ofs + cur->tf_size;
774 			ofs = (ofs + 0x1ff) & ~0x1ff;
775 			while (pkg->pkg_ofs < ofs) {
776 				if (get_zipped(pkg, buf, sizeof(buf)) == -1) {
777 					free(cur);
778 					return (NULL);
779 				}
780 			}
781 		}
782 
783 		if (last != NULL)
784 			last->tf_next = cur;
785 		else
786 			pkg->pkg_first = cur;
787 		pkg->pkg_last = cur;
788 	}
789 
790 	return (cur);
791 }
792