 @@ -395,32 +395,32 @@ static void	parse_rockridge_SL1(struct f
 		    const unsigned char *, int);
 static void	parse_rockridge_TF1(struct file_info *,
 		    const unsigned char *, int);
 static void	parse_rockridge_ZF1(struct file_info *,
 		    const unsigned char *, int);
 static void	register_file(struct iso9660 *, struct file_info *);
 static void	release_files(struct iso9660 *);
 static unsigned	toi(const void *p, int n);
 static inline void cache_add_entry(struct iso9660 *iso9660,
 		    struct file_info *file);
 static inline void cache_add_to_next_of_parent(struct iso9660 *iso9660,
 		    struct file_info *file);
 static inline struct file_info *cache_get_entry(struct iso9660 *iso9660);
-static void	heap_add_entry(struct heap_queue *heap,
+static int	heap_add_entry(struct archive_read *a, struct heap_queue *heap,
 		    struct file_info *file, uint64_t key);
 static struct file_info *heap_get_entry(struct heap_queue *heap);
-#define add_entry(iso9660, file)	\
+#define add_entry(arch, iso9660, file)	\
-	heap_add_entry(&((iso9660)->pending_files), file, file->offset)
+	heap_add_entry(arch, &((iso9660)->pending_files), file, file->offset)
 #define next_entry(iso9660)		\
 	heap_get_entry(&((iso9660)->pending_files))
 int
 archive_read_support_format_iso9660(struct archive *_a)
+{
 	struct archive_read *a = (struct archive_read *)_a;
 	struct iso9660 *iso9660;
 	int r;
 	iso9660 = (struct iso9660 *)malloc(sizeof(*iso9660));
 	if (iso9660 == NULL) {
 		archive_set_error(&a->archive, ENOMEM, "Can't allocate iso9660 data");
 @@ -958,135 +958,146 @@ read_children(struct archive_read *a, st
 			/* Skip '.' entry. */
 			if (*(p + DR_name_len_offset) == 1
 			    && *(p + DR_name_offset) == '\0')
 				continue;
 			/* Skip '..' entry. */
 			if (*(p + DR_name_len_offset) == 1
 			    && *(p + DR_name_offset) == '\001')
 				continue;
 			child = parse_file_info(a, parent, p);
 			if (child == NULL)
 				return (ARCHIVE_FATAL);
 			if (child->cl_offset)
-				heap_add_entry(&(iso9660->cl_files),
+				if (heap_add_entry(a, &(iso9660->cl_files),
-				    child, child->cl_offset);
+				    child, child->cl_offset) != ARCHIVE_OK)
 					return (ARCHIVE_FATAL);
 			else {
 				if (child->multi_extent || multi != NULL) {
 					struct content *con;
 					if (multi == NULL) {
 						multi = child;
 						multi->contents.first = NULL;
 						multi->contents.last =
 						    &(multi->contents.first);
+					}
 					con = malloc(sizeof(struct content));
 					if (con == NULL) {
 						archive_set_error(
 						    &a->archive, ENOMEM,
 						    "No memory for "
 						    "multi extent");
 						return (ARCHIVE_FATAL);
+					}
 					con->offset = child->offset;
 					con->size = child->size;
 					con->next = NULL;
 					*multi->contents.last = con;
 					multi->contents.last = &(con->next);
-					if (multi == child)
+					if (multi == child) {
-						add_entry(iso9660, child);
+						if (add_entry(a, iso9660, child)
-					else {
+						    != ARCHIVE_OK)
 							return (ARCHIVE_FATAL);
 					} else {
 						multi->size += child->size;
 						if (!child->multi_extent)
 							multi = NULL;
+					}
 				} else
-					add_entry(iso9660, child);
+					if (add_entry(a, iso9660, child)
 					    != ARCHIVE_OK)
 						return (ARCHIVE_FATAL);
+			}
+		}
+	}
 	/* Read data which recorded by RRIP "CE" extension. */
 	if (read_CE(a, iso9660) != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 	return (ARCHIVE_OK);
+}
 static int
-relocate_dir(struct iso9660 *iso9660, struct file_info *file)
+relocate_dir(struct archive_read *a, struct iso9660 *iso9660,
 	struct file_info *file)
+{
 	struct file_info *re;
 	re = heap_get_entry(&(iso9660->re_dirs));
 	while (re != NULL && re->offset < file->cl_offset) {
 		/* This case is wrong pattern.
 		 * But dont't reject this directory entry to be robust. */
 		cache_add_entry(iso9660, re);
 		re = heap_get_entry(&(iso9660->re_dirs));
+	}
 	if (re == NULL)
 		/* This case is wrong pattern. */
 		return (0);
 	if (re->offset == file->cl_offset) {
 		re->parent->subdirs--;
 		re->parent = file->parent;
 		re->parent->subdirs++;
 		cache_add_to_next_of_parent(iso9660, re);
 		return (1);
 	} else
 		/* This case is wrong pattern. */
-		heap_add_entry(&(iso9660->re_dirs), re, re->offset);
+		if (heap_add_entry(a, &(iso9660->re_dirs), re, re->offset)
 		    != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 	return (0);
+}
 static int
 read_entries(struct archive_read *a)
+{
 	struct iso9660 *iso9660;
 	struct file_info *file;
 	int r;
 	iso9660 = (struct iso9660 *)(a->format->data);
 	while ((file = next_entry(iso9660)) != NULL &&
 	    (file->mode & AE_IFMT) == AE_IFDIR) {
 		r = read_children(a, file);
 		if (r != ARCHIVE_OK)
 			return (r);
 		if (iso9660->seenRockridge &&
 		    file->parent != NULL &&
 		    file->parent->parent == NULL &&
 		    iso9660->rr_moved == NULL &&
 		    (strcmp(file->name.s, "rr_moved") == 0 ||
 		     strcmp(file->name.s, ".rr_moved") == 0)) {
 			iso9660->rr_moved = file;
 		} else if (file->re)
-			heap_add_entry(&(iso9660->re_dirs), file,
+			if (heap_add_entry(a, &(iso9660->re_dirs), file,
-			    file->offset);
+			    file->offset) != ARCHIVE_OK)
 				return (ARCHIVE_FATAL);
 		else
 			cache_add_entry(iso9660, file);
+	}
 	if (file != NULL)
-		add_entry(iso9660, file);
+		if (add_entry(a, iso9660, file) != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 	if (iso9660->rr_moved != NULL) {
 		/*
 		 * Relocate directory which rr_moved has.
 		 */
 		while ((file = heap_get_entry(&(iso9660->cl_files))) != NULL)
-			relocate_dir(iso9660, file);
+			if (relocate_dir(a, iso9660, file) != ARCHIVE_OK)
 				return ARCHIVE_FATAL;
 		/* If rr_moved directory still has children,
 		 * Add rr_moved into pending_files to show
 		 */
 		if (iso9660->rr_moved->subdirs) {
 			cache_add_entry(iso9660, iso9660->rr_moved);
 			/* If entries which have "RE" extension are still
 			 * remaining(this case is unlikely except ISO image
 			 * is broken), the entries won't be exposed. */
 			while ((file = heap_get_entry(&(iso9660->re_dirs))) != NULL)
 				cache_add_entry(iso9660, file);
 		} else
 			iso9660->rr_moved->parent->subdirs--;
 @@ -1182,27 +1193,28 @@ archive_read_format_iso9660_read_header(
 				    ARCHIVE_ERRNO_MISC,
 				    "Failed to read full block when scanning "
 				    "ISO9660 directory list");
 				return (ARCHIVE_FATAL);
+			}
 			seenJoliet = iso9660->seenJoliet;/* Save flag. */
 			iso9660->seenJoliet = 0;
 			file = parse_file_info(a, NULL, block);
 			if (file == NULL)
 				return (ARCHIVE_FATAL);
 			iso9660->seenJoliet = seenJoliet;
+		}
 		/* Store the root directory in the pending list. */
-		add_entry(iso9660, file);
+		if (add_entry(a, iso9660, file) != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 		if (iso9660->seenRockridge) {
 			a->archive.archive_format =
 			    ARCHIVE_FORMAT_ISO9660_ROCKRIDGE;
 			a->archive.archive_format_name =
 			    "ISO9660 with Rockridge extensions";
+		}
 		rd_r = read_entries(a);
 		if (rd_r == ARCHIVE_FATAL)
 			return (ARCHIVE_FATAL);
 	} else
 		rd_r = ARCHIVE_OK;
 	/* Get the next entry that appears after the current offset. */
 @@ -2609,72 +2621,81 @@ cache_add_to_next_of_parent(struct iso96
 static inline struct file_info *
 cache_get_entry(struct iso9660 *iso9660)
+{
 	struct file_info *file;
 	if ((file = iso9660->cache_files.first) != NULL) {
 		iso9660->cache_files.first = file->next;
 		if (iso9660->cache_files.first == NULL)
 			iso9660->cache_files.last = &(iso9660->cache_files.first);
+	}
 	return (file);
+}
-static void
+static int
-heap_add_entry(struct heap_queue *heap, struct file_info *file, uint64_t key)
+heap_add_entry(struct archive_read *a, struct heap_queue *heap,
 	struct file_info *file, uint64_t key)
+{
 	uint64_t file_key, parent_key;
 	int hole, parent;
 	/* Expand our pending files list as necessary. */
 	if (heap->used >= heap->allocated) {
 		struct file_info **new_pending_files;
 		int new_size = heap->allocated * 2;
 		if (heap->allocated < 1024)
 			new_size = 1024;
 		/* Overflow might keep us from growing the list. */
-		if (new_size <= heap->allocated)
+		if (new_size <= heap->allocated) {
-			__archive_errx(1, "Out of memory");
+			archive_set_error(&a->archive,
 			    ENOMEM, "Out of memory");
 			return (ARCHIVE_FATAL);
+		}
 		new_pending_files = (struct file_info **)
 		    malloc(new_size * sizeof(new_pending_files[0]));
-		if (new_pending_files == NULL)
+		if (new_pending_files == NULL) {
-			__archive_errx(1, "Out of memory");
+			archive_set_error(&a->archive,
 			    ENOMEM, "Out of memory");
 			return (ARCHIVE_FATAL);
+		}
 		memcpy(new_pending_files, heap->files,
 		    heap->allocated * sizeof(new_pending_files[0]));
 		if (heap->files != NULL)
 			free(heap->files);
 		heap->files = new_pending_files;
 		heap->allocated = new_size;
+	}
 	file_key = file->key = key;
 	/*
 	 * Start with hole at end, walk it up tree to find insertion point.
 	 */
 	hole = heap->used++;
 	while (hole > 0) {
 		parent = (hole - 1)/2;
 		parent_key = heap->files[parent]->key;
 		if (file_key >= parent_key) {
 			heap->files[hole] = file;
 			return;
+		}
 		// Move parent into hole <==> move hole up tree.
 		heap->files[hole] = heap->files[parent];
 		hole = parent;
+	}
 	heap->files[0] = file;
 	return (ARCHIVE_OK);
+}
 static struct file_info *
 heap_get_entry(struct heap_queue *heap)
+{
 	uint64_t a_key, b_key, c_key;
 	int a, b, c;
 	struct file_info *r, *tmp;
 	if (heap->used < 1)
 		return (NULL);
 	/*

 @@ -165,34 +165,35 @@ struct tar {
 	int64_t			 realsize;
 	struct sparse_block	*sparse_list;
 	struct sparse_block	*sparse_last;
 	int64_t			 sparse_offset;
 	int64_t			 sparse_numbytes;
 	int			 sparse_gnu_major;
 	int			 sparse_gnu_minor;
 	char			 sparse_gnu_pending;
 };
 static ssize_t	UTF8_mbrtowc(wchar_t *pwc, const char *s, size_t n);
 static int	archive_block_is_null(const unsigned char *p);
 static char	*base64_decode(const char *, size_t, size_t *);
-static void	 gnu_add_sparse_entry(struct tar *,
+static int	gnu_add_sparse_entry(struct archive_read *, struct tar *,
 		    off_t offset, off_t remaining);
 static void	gnu_clear_sparse_list(struct tar *);
 static int	gnu_sparse_old_read(struct archive_read *, struct tar *,
 		    const struct archive_entry_header_gnutar *header);
-static void	gnu_sparse_old_parse(struct tar *,
+static int	gnu_sparse_old_parse(struct archive_read *, struct tar *,
 		    const struct gnu_sparse *sparse, int length);
-static int	gnu_sparse_01_parse(struct tar *, const char *);
+static int	gnu_sparse_01_parse(struct archive_read *, struct tar *,
 		    const char *);
 static ssize_t	gnu_sparse_10_read(struct archive_read *, struct tar *);
 static int	header_Solaris_ACL(struct archive_read *,  struct tar *,
 		    struct archive_entry *, const void *);
 static int	header_common(struct archive_read *,  struct tar *,
 		    struct archive_entry *, const void *);
 static int	header_old_tar(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *);
 static int	header_pax_extensions(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *);
 static int	header_pax_global(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *h);
 static int	header_longlink(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *h);
 @@ -202,28 +203,28 @@ static int	header_volume(struct archive_
 		    struct archive_entry *, const void *h);
 static int	header_ustar(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *h);
 static int	header_gnutar(struct archive_read *, struct tar *,
 		    struct archive_entry *, const void *h);
 static int	archive_read_format_tar_bid(struct archive_read *);
 static int	archive_read_format_tar_cleanup(struct archive_read *);
 static int	archive_read_format_tar_read_data(struct archive_read *a,
 		    const void **buff, size_t *size, off_t *offset);
 static int	archive_read_format_tar_skip(struct archive_read *a);
 static int	archive_read_format_tar_read_header(struct archive_read *,
 		    struct archive_entry *);
 static int	checksum(struct archive_read *, const void *);
-static int 	pax_attribute(struct tar *, struct archive_entry *,
+static int 	pax_attribute(struct archive_read *, struct tar *,
-		    char *key, char *value);
+		    struct archive_entry *, char *key, char *value);
 static int 	pax_header(struct archive_read *, struct tar *,
 		    struct archive_entry *, char *attr);
 static void	pax_time(const char *, int64_t *sec, long *nanos);
 static ssize_t	readline(struct archive_read *, struct tar *, const char **,
 		    ssize_t limit);
 static int	read_body_to_string(struct archive_read *, struct tar *,
 		    struct archive_string *, const void *h);
 static int64_t	tar_atol(const char *, unsigned);
 static int64_t	tar_atol10(const char *, unsigned);
 static int64_t	tar_atol256(const char *, unsigned);
 static int64_t	tar_atol8(const char *, unsigned);
 static int	tar_read_header(struct archive_read *, struct tar *,
 		    struct archive_entry *);
 @@ -409,27 +410,29 @@ archive_read_format_tar_read_header(stru
 		tar->sparse_list = sp->next;
 		free(sp);
+	}
 	tar->sparse_last = NULL;
 	tar->realsize = -1; /* Mark this as "unset" */
 	r = tar_read_header(a, tar, entry);
 	/*
 	 * "non-sparse" files are really just sparse files with
 	 * a single block.
 	 */
 	if (tar->sparse_list == NULL)
-		gnu_add_sparse_entry(tar, 0, tar->entry_bytes_remaining);
+		if (gnu_add_sparse_entry(a, tar, 0, tar->entry_bytes_remaining)
 		    != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 	if (r == ARCHIVE_OK) {
 		/*
 		 * "Regular" entry with trailing '/' is really
 		 * directory: This is needed for certain old tar
 		 * variants and even for some broken newer ones.
 		 */
 		p = archive_entry_pathname(entry);
 		l = strlen(p);
 		if (archive_entry_filetype(entry) == AE_IFREG
 		    && p[l-1] == '/')
 			archive_entry_set_filetype(entry, AE_IFDIR);
+	}
 @@ -1259,27 +1262,27 @@ pax_header(struct archive_read *a, struc
 		while (*p && *p != '=')
 			++p;
 		if (*p == '\0') {
 			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 			    "Invalid pax extended attributes");
 			return (ARCHIVE_WARN);
+		}
 		*p = '\0';
 		/* Identify null-terminated 'value' portion. */
 		value = p + 1;
 		/* Identify this attribute and set it in the entry. */
-		err2 = pax_attribute(tar, entry, key, value);
+		err2 = pax_attribute(a, tar, entry, key, value);
 		err = err_combine(err, err2);
 		/* Skip to next line */
 		attr += line_length;
 		attr_length -= line_length;
+	}
 	if (archive_strlen(&(tar->entry_gname)) > 0) {
 		value = tar->entry_gname.s;
 		if (tar->pax_hdrcharset_binary)
 			archive_entry_copy_gname(entry, value);
 		else {
 			if (!archive_entry_update_gname_utf8(entry, value)) {
 				err = ARCHIVE_WARN;
 @@ -1385,70 +1388,74 @@ pax_attribute_xattr(struct archive_entry
  * Parse a single key=value attribute.  key/value pointers are
  * assumed to point into reasonably long-lived storage.
+ *
  * Note that POSIX reserves all-lowercase keywords.  Vendor-specific
  * extensions should always have keywords of the form "VENDOR.attribute"
  * In particular, it's quite feasible to support many different
  * vendor extensions here.  I'm using "LIBARCHIVE" for extensions
  * unique to this library.
+ *
  * Investigate other vendor-specific extensions and see if
  * any of them look useful.
  */
 static int
-pax_attribute(struct tar *tar, struct archive_entry *entry,
+pax_attribute(struct archive_read *a, struct tar *tar,
-    char *key, char *value)
+	struct archive_entry *entry, char *key, char *value)
+{
 	int64_t s;
 	long n;
 	wchar_t *wp;
 	switch (key[0]) {
 	case 'G':
 		/* GNU "0.0" sparse pax format. */
 		if (strcmp(key, "GNU.sparse.numblocks") == 0) {
 			tar->sparse_offset = -1;
 			tar->sparse_numbytes = -1;
 			tar->sparse_gnu_major = 0;
 			tar->sparse_gnu_minor = 0;
+		}
 		if (strcmp(key, "GNU.sparse.offset") == 0) {
 			tar->sparse_offset = tar_atol10(value, strlen(value));
 			if (tar->sparse_numbytes != -1) {
-				gnu_add_sparse_entry(tar,
+				if (gnu_add_sparse_entry(a, tar,
-				    tar->sparse_offset, tar->sparse_numbytes);
+				    tar->sparse_offset, tar->sparse_numbytes)
 				    != ARCHIVE_OK)
 					return (ARCHIVE_FATAL);
 				tar->sparse_offset = -1;
 				tar->sparse_numbytes = -1;
+			}
+		}
 		if (strcmp(key, "GNU.sparse.numbytes") == 0) {
 			tar->sparse_numbytes = tar_atol10(value, strlen(value));
 			if (tar->sparse_numbytes != -1) {
-				gnu_add_sparse_entry(tar,
+				if (gnu_add_sparse_entry(a, tar,
-				    tar->sparse_offset, tar->sparse_numbytes);
+				    tar->sparse_offset, tar->sparse_numbytes)
 				    != ARCHIVE_OK)
 					return (ARCHIVE_FATAL);
 				tar->sparse_offset = -1;
 				tar->sparse_numbytes = -1;
+			}
+		}
 		if (strcmp(key, "GNU.sparse.size") == 0) {
 			tar->realsize = tar_atol10(value, strlen(value));
 			archive_entry_set_size(entry, tar->realsize);
+		}
 		/* GNU "0.1" sparse pax format. */
 		if (strcmp(key, "GNU.sparse.map") == 0) {
 			tar->sparse_gnu_major = 0;
 			tar->sparse_gnu_minor = 1;
-			if (gnu_sparse_01_parse(tar, value) != ARCHIVE_OK)
+			if (gnu_sparse_01_parse(a, tar, value) != ARCHIVE_OK)
 				return (ARCHIVE_WARN);
+		}
 		/* GNU "1.0" sparse pax format */
 		if (strcmp(key, "GNU.sparse.major") == 0) {
 			tar->sparse_gnu_major = tar_atol10(value, strlen(value));
 			tar->sparse_gnu_pending = 1;
+		}
 		if (strcmp(key, "GNU.sparse.minor") == 0) {
 			tar->sparse_gnu_minor = tar_atol10(value, strlen(value));
 			tar->sparse_gnu_pending = 1;
+		}
 		if (strcmp(key, "GNU.sparse.name") == 0) {
 @@ -1706,52 +1713,57 @@ header_gnutar(struct archive_read *a, st
 	/* Grab GNU-specific fields. */
 	archive_entry_set_atime(entry,
 	    tar_atol(header->atime, sizeof(header->atime)), 0);
 	archive_entry_set_ctime(entry,
 	    tar_atol(header->ctime, sizeof(header->ctime)), 0);
 	if (header->realsize[0] != 0) {
 		tar->realsize
 		    = tar_atol(header->realsize, sizeof(header->realsize));
 		archive_entry_set_size(entry, tar->realsize);
+	}
 	if (header->sparse[0].offset[0] != 0) {
-		gnu_sparse_old_read(a, tar, header);
+		if (gnu_sparse_old_read(a, tar, header) != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 	} else {
 		if (header->isextended[0] != 0) {
 			/* XXX WTF? XXX */
+		}
+	}
 	return (0);
+}
-static void
+static int
-gnu_add_sparse_entry(struct tar *tar, off_t offset, off_t remaining)
+gnu_add_sparse_entry(struct archive_read *a, struct tar *tar, off_t offset,
 	off_t remaining)
+{
 	struct sparse_block *p;
 	p = (struct sparse_block *)malloc(sizeof(*p));
-	if (p == NULL)
+	if (p == NULL) {
-		__archive_errx(1, "Out of memory");
+		archive_set_error(&a->archive, ENOMEM, "Out of memory");
 		return (ARCHIVE_FATAL);
+	}
 	memset(p, 0, sizeof(*p));
 	if (tar->sparse_last != NULL)
 		tar->sparse_last->next = p;
 	else
 		tar->sparse_list = p;
 	tar->sparse_last = p;
 	p->offset = offset;
 	p->remaining = remaining;
 	return (ARCHIVE_OK);
+}
 static void
 gnu_clear_sparse_list(struct tar *tar)
+{
 	struct sparse_block *p;
 	while (tar->sparse_list != NULL) {
 		p = tar->sparse_list;
 		tar->sparse_list = p->next;
 		free(p);
+	}
 	tar->sparse_last = NULL;
 @@ -1772,60 +1784,65 @@ gnu_clear_sparse_list(struct tar *tar)
 static int
 gnu_sparse_old_read(struct archive_read *a, struct tar *tar,
     const struct archive_entry_header_gnutar *header)
+{
 	ssize_t bytes_read;
 	const void *data;
 	struct extended {
 		struct gnu_sparse sparse[21];
 		char	isextended[1];
 		char	padding[7];
 	};
 	const struct extended *ext;
-	gnu_sparse_old_parse(tar, header->sparse, 4);
+	if (gnu_sparse_old_parse(a, tar, header->sparse, 4) != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 	if (header->isextended[0] == 0)
 		return (ARCHIVE_OK);
 	do {
 		data = __archive_read_ahead(a, 512, &bytes_read);
 		if (bytes_read < 0)
 			return (ARCHIVE_FATAL);
 		if (bytes_read < 512) {
 			archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
 			    "Truncated tar archive "
 			    "detected while reading sparse file data");
 			return (ARCHIVE_FATAL);
+		}
 		__archive_read_consume(a, 512);
 		ext = (const struct extended *)data;
-		gnu_sparse_old_parse(tar, ext->sparse, 21);
+		if (gnu_sparse_old_parse(a, tar, ext->sparse, 21) != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 	} while (ext->isextended[0] != 0);
 	if (tar->sparse_list != NULL)
 		tar->entry_offset = tar->sparse_list->offset;
 	return (ARCHIVE_OK);
+}
-static void
+static int
-gnu_sparse_old_parse(struct tar *tar,
+gnu_sparse_old_parse(struct archive_read *a, struct tar *tar,
     const struct gnu_sparse *sparse, int length)
+{
 	while (length > 0 && sparse->offset[0] != 0) {
-		gnu_add_sparse_entry(tar,
+		if (gnu_add_sparse_entry(a, tar,
 		    tar_atol(sparse->offset, sizeof(sparse->offset)),
-		    tar_atol(sparse->numbytes, sizeof(sparse->numbytes)));
+		    tar_atol(sparse->numbytes, sizeof(sparse->numbytes)))
 		    != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
 		sparse++;
 		length--;
+	}
 	return (ARCHIVE_OK);
+}
 /*
  * GNU tar sparse format 0.0
+ *
  * Beginning with GNU tar 1.15, sparse files are stored using
  * information in the pax extended header.  The GNU tar maintainers
  * have gone through a number of variations in the process of working
  * out this scheme; furtunately, they're all numbered.
+ *
  * Sparse format 0.0 uses attribute GNU.sparse.numblocks to store the
  * number of blocks, and GNU.sparse.offset/GNU.sparse.numbytes to
  * store offset/size for each block.  The repeated instances of these
 @@ -1835,47 +1852,49 @@ gnu_sparse_old_parse(struct tar *tar,
 /*
  * GNU tar sparse format 0.1
+ *
  * This version replaced the offset/numbytes attributes with
  * a single "map" attribute that stored a list of integers.  This
  * format had two problems: First, the "map" attribute could be very
  * long, which caused problems for some implementations.  More
  * importantly, the sparse data was lost when extracted by archivers
  * that didn't recognize this extension.
  */
 static int
-gnu_sparse_01_parse(struct tar *tar, const char *p)
+gnu_sparse_01_parse(struct archive_read *a, struct tar *tar, const char *p)
+{
 	const char *e;
 	off_t offset = -1, size = -1;
 	for (;;) {
 		e = p;
 		while (*e != '\0' && *e != ',') {
 			if (*e < '0' || *e > '9')
 				return (ARCHIVE_WARN);
 			e++;
+		}
 		if (offset < 0) {
 			offset = tar_atol10(p, e - p);
 			if (offset < 0)
 				return (ARCHIVE_WARN);
 		} else {
 			size = tar_atol10(p, e - p);
 			if (size < 0)
 				return (ARCHIVE_WARN);
-			gnu_add_sparse_entry(tar, offset, size);
+			if (gnu_add_sparse_entry(a, tar, offset, size)
 			    != ARCHIVE_OK)
 				return (ARCHIVE_FATAL);
 			offset = -1;
+		}
 		if (*e == '\0')
 			return (ARCHIVE_OK);
 		p = e + 1;
+	}
+}
 /*
  * GNU tar sparse format 1.0
+ *
  * The idea: The offset/size data is stored as a series of base-10
  * ASCII numbers prepended to the file data, so that dearchivers that
 @@ -1959,27 +1978,28 @@ gnu_sparse_10_read(struct archive_read *
 	entries = gnu_sparse_10_atol(a, tar, &remaining);
 	if (entries < 0)
 		return (ARCHIVE_FATAL);
 	/* Parse the individual entries. */
 	while (entries-- > 0) {
 		/* Parse offset/size */
 		offset = gnu_sparse_10_atol(a, tar, &remaining);
 		if (offset < 0)
 			return (ARCHIVE_FATAL);
 		size = gnu_sparse_10_atol(a, tar, &remaining);
 		if (size < 0)
 			return (ARCHIVE_FATAL);
 		/* Add a new sparse entry. */
-		gnu_add_sparse_entry(tar, offset, size);
+		if (gnu_add_sparse_entry(a, tar, offset, size) != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
+	}
 	/* Skip rest of block... */
 	bytes_read = tar->entry_bytes_remaining - remaining;
 	to_skip = 0x1ff & -bytes_read;
 	if (to_skip != __archive_read_skip(a, to_skip))
 		return (ARCHIVE_FATAL);
 	return (bytes_read + to_skip);
+}
 /*-
  * Convert text->integer.
+ *
  * Traditional tar formats (including POSIX) specify base-8 for

 @@ -1,24 +1,24 @@
-# $NetBSD: Makefile,v 1.39 2014/02/12 23:17:32 tron Exp $
+# $NetBSD: Makefile,v 1.39.2.1 2014/04/24 09:34:06 tron Exp $
+#
 DISTNAME=	libarchive-2.8.4
-PKGREVISION=	3
+PKGREVISION=	4
 CATEGORIES=	archivers
 MASTER_SITES=	# empty
 DISTFILES=	# empty
 MAINTAINER=	joerg@NetBSD.org
-HOMEPAGE=	http://code.google.com/p/libarchive/
+HOMEPAGE=	http://www.libarchive.org/
 COMMENT=	Library to read/create different archive formats
 GNU_CONFIGURE=	yes
 USE_LIBTOOL=	yes
 CONFIGURE_ARGS+=	--disable-bsdtar --without-expat --without-xml2 \
 			--disable-bsdcpio
 do-extract:
 	${CP} -r ${FILESDIR} ${WRKSRC}
 .include "../../mk/bsd.prefs.mk"