libarchive-static 1.0.6 → 1.1.0

data/ext/{libarchive-2.8.4/libarchive/archive_read_support_compression_uu.c → libarchive-3.6.2/libarchive/archive_read_support_filter_uu.c}

@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2009 Michihiro NAKAJIMA
+ * Copyright (c) 2009-2011 Michihiro NAKAJIMA
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24,7 +24,7 @@
  */
 
 #include "archive_platform.h"
-__FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_uu.c 201248 2009-12-30 06:12:03Z kientzle $");
+__FBSDID("$FreeBSD$");
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
@@ -40,6 +40,9 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_uu.c 20
 #include "archive_private.h"
 #include "archive_read_private.h"
 
+/* Maximum lookahead during bid phase */
+#define UUENCODE_BID_MAX_READ 128*1024 /* in bytes */
+
 struct uudecode {
 	int64_t		 total;
 	unsigned char	*in_buff;
@@ -53,6 +56,7 @@ struct uudecode {
 #define ST_READ_UU	1
 #define ST_UUEND	2
 #define ST_READ_BASE64	3
+#define ST_IGNORE	4
 };
 
 static int	uudecode_bidder_bid(struct archive_read_filter_bidder *,
@@ -63,23 +67,28 @@ static ssize_t	uudecode_filter_read(struct archive_read_filter *,
 		    const void **);
 static int	uudecode_filter_close(struct archive_read_filter *);
 
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Deprecated; remove in libarchive 4.0 */
 int
-archive_read_support_compression_uu(struct archive *_a)
+archive_read_support_compression_uu(struct archive *a)
 {
-	struct archive_read *a = (struct archive_read *)_a;
-	struct archive_read_filter_bidder *bidder;
+	return archive_read_support_filter_uu(a);
+}
+#endif
 
-	bidder = __archive_read_get_bidder(a);
-	archive_clear_error(_a);
-	if (bidder == NULL)
-		return (ARCHIVE_FATAL);
+static const struct archive_read_filter_bidder_vtable
+uudecode_bidder_vtable = {
+	.bid = uudecode_bidder_bid,
+	.init = uudecode_bidder_init,
+};
 
-	bidder->data = NULL;
-	bidder->bid = uudecode_bidder_bid;
-	bidder->init = uudecode_bidder_init;
-	bidder->options = NULL;
-	bidder->free = NULL;
-	return (ARCHIVE_OK);
+int
+archive_read_support_filter_uu(struct archive *_a)
+{
+	struct archive_read *a = (struct archive_read *)_a;
+
+	return __archive_read_register_bidder(a, NULL, "uu",
+			&uudecode_bidder_vtable);
 }
 
 static const unsigned char ascii[256] = {
@@ -194,7 +203,8 @@ get_line(const unsigned char *b, ssize_t avail, ssize_t *nlsize)
 
 static ssize_t
 bid_get_line(struct archive_read_filter *filter,
-    const unsigned char **b, ssize_t *avail, ssize_t *ravail, ssize_t *nl)
+    const unsigned char **b, ssize_t *avail, ssize_t *ravail,
+    ssize_t *nl, size_t* nbytes_read)
 {
 	ssize_t len;
 	int quit;
@@ -205,24 +215,37 @@ bid_get_line(struct archive_read_filter *filter,
 		len = 0;
 	} else
 		len = get_line(*b, *avail, nl);
+
 	/*
 	 * Read bytes more while it does not reach the end of line.
 	 */
-	while (*nl == 0 && len == *avail && !quit) {
+	while (*nl == 0 && len == *avail && !quit &&
+	    *nbytes_read < UUENCODE_BID_MAX_READ) {
 		ssize_t diff = *ravail - *avail;
+		size_t nbytes_req = (*ravail+1023) & ~1023U;
+		ssize_t tested;
+
+		/* Increase reading bytes if it is not enough to at least
+		 * new two lines. */
+		if (nbytes_req < (size_t)*ravail + 160)
+			nbytes_req <<= 1;
 
-		*b = __archive_read_filter_ahead(filter, 160 + *ravail, avail);
+		*b = __archive_read_filter_ahead(filter, nbytes_req, avail);
 		if (*b == NULL) {
 			if (*ravail >= *avail)
 				return (0);
-			/* Reading bytes reaches the end of file. */
+			/* Reading bytes reaches the end of a stream. */
 			*b = __archive_read_filter_ahead(filter, *avail, avail);
 			quit = 1;
 		}
+		*nbytes_read = *avail;
 		*ravail = *avail;
 		*b += diff;
 		*avail -= diff;
-		len = get_line(*b, *avail, nl);
+		tested = len;/* Skip some bytes we already determined. */
+		len = get_line(*b + tested, *avail - tested, nl);
+		if (len >= 0)
+			len += tested;
 	}
 	return (len);
 }
@@ -238,6 +261,7 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 	ssize_t len, nl;
 	int l;
 	int firstline;
+	size_t nbytes_read;
 
 	(void)self; /* UNUSED */
 
@@ -247,13 +271,14 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 
 	firstline = 20;
 	ravail = avail;
+	nbytes_read = avail;
 	for (;;) {
-		len = bid_get_line(filter, &b, &avail, &ravail, &nl);
+		len = bid_get_line(filter, &b, &avail, &ravail, &nl, &nbytes_read);
 		if (len < 0 || nl == 0)
-			return (0);/* Binary data. */
-		if (memcmp(b, "begin ", 6) == 0 && len - nl >= 11)
+			return (0); /* No match found. */
+		if (len - nl >= 11 && memcmp(b, "begin ", 6) == 0)
 			l = 6;
-		else if (memcmp(b, "begin-base64 ", 13) == 0 && len - nl >= 18)
+		else if (len -nl >= 18 && memcmp(b, "begin-base64 ", 13) == 0)
 			l = 13;
 		else
 			l = 0;
@@ -268,15 +293,20 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 		if (l)
 			break;
 		firstline = 0;
+
+		/* Do not read more than UUENCODE_BID_MAX_READ bytes */
+		if (nbytes_read >= UUENCODE_BID_MAX_READ)
+			return (0);
 	}
 	if (!avail)
 		return (0);
-	len = bid_get_line(filter, &b, &avail, &ravail, &nl);
+	len = bid_get_line(filter, &b, &avail, &ravail, &nl, &nbytes_read);
 	if (len < 0 || nl == 0)
 		return (0);/* There are non-ascii characters. */
 	avail -= len;
 
 	if (l == 6) {
+		/* "begin " */
 		if (!uuchar[*b])
 			return (0);
 		/* Get a length of decoded bytes. */
@@ -284,30 +314,14 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 		if (l > 45)
 			/* Normally, maximum length is 45(character 'M'). */
 			return (0);
-		while (l && len-nl > 0) {
-			if (l > 0) {
-				if (!uuchar[*b++])
-					return (0);
-				if (!uuchar[*b++])
-					return (0);
-				len -= 2;
-				--l;
-			}
-			if (l > 0) {
-				if (!uuchar[*b++])
-					return (0);
-				--len;
-				--l;
-			}
-			if (l > 0) {
-				if (!uuchar[*b++])
-					return (0);
-				--len;
-				--l;
-			}
+		if (l > len - nl)
+			return (0); /* Line too short. */
+		while (l) {
+			if (!uuchar[*b++])
+				return (0);
+			--len;
+			--l;
 		}
-		if (len-nl < 0)
-			return (0);
 		if (len-nl == 1 &&
 		    (uuchar[*b] ||		 /* Check sum. */
 		     (*b >= 'a' && *b <= 'z'))) {/* Padding data(MINIX). */
@@ -317,8 +331,8 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 		b += nl;
 		if (avail && uuchar[*b])
 			return (firstline+30);
-	}
-	if (l == 13) {
+	} else if (l == 13) {
+		/* "begin-base64 " */
 		while (len-nl > 0) {
 			if (!base64[*b++])
 				return (0);
@@ -337,6 +351,12 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self,
 	return (0);
 }
 
+static const struct archive_read_filter_vtable
+uudecode_reader_vtable = {
+	.read = uudecode_filter_read,
+	.close = uudecode_filter_close,
+};
+
 static int
 uudecode_bidder_init(struct archive_read_filter *self)
 {
@@ -344,11 +364,8 @@ uudecode_bidder_init(struct archive_read_filter *self)
 	void *out_buff;
 	void *in_buff;
 
-	self->code = ARCHIVE_COMPRESSION_UU;
+	self->code = ARCHIVE_FILTER_UU;
 	self->name = "uu";
-	self->read = uudecode_filter_read;
-	self->skip = NULL; /* not supported */
-	self->close = uudecode_filter_close;
 
 	uudecode = (struct uudecode *)calloc(sizeof(*uudecode), 1);
 	out_buff = malloc(OUT_BUFF_SIZE);
@@ -368,6 +385,7 @@ uudecode_bidder_init(struct archive_read_filter *self)
 	uudecode->in_allocated = IN_BUFF_SIZE;
 	uudecode->out_buff = out_buff;
 	uudecode->state = ST_FIND_HEAD;
+	self->vtable = &uudecode_reader_vtable;
 
 	return (ARCHIVE_OK);
 }
@@ -381,19 +399,30 @@ ensure_in_buff_size(struct archive_read_filter *self,
 		unsigned char *ptr;
 		size_t newsize;
 
-		newsize = uudecode->in_allocated << 1;
+		/*
+		 * Calculate a new buffer size for in_buff.
+		 * Increase its value until it has enough size we need.
+		 */
+		newsize = uudecode->in_allocated;
+		do {
+			if (newsize < IN_BUFF_SIZE*32)
+				newsize <<= 1;
+			else
+				newsize += IN_BUFF_SIZE;
+		} while (size > newsize);
+		/* Allocate the new buffer. */
 		ptr = malloc(newsize);
-		if (ptr == NULL ||
-		    newsize < uudecode->in_allocated) {
+		if (ptr == NULL) {
 			free(ptr);
 			archive_set_error(&self->archive->archive,
 			    ENOMEM,
     			    "Can't allocate data for uudecode");
 			return (ARCHIVE_FATAL);
 		}
+		/* Move the remaining data in in_buff into the new buffer. */
 		if (uudecode->in_cnt)
-			memmove(ptr, uudecode->in_buff,
-			    uudecode->in_cnt);
+			memmove(ptr, uudecode->in_buff, uudecode->in_cnt);
+		/* Replace in_buff with the new buffer. */
 		free(uudecode->in_buff);
 		uudecode->in_buff = ptr;
 		uudecode->in_allocated = newsize;
@@ -426,6 +455,10 @@ read_more:
 	total = 0;
 	out = uudecode->out_buff;
 	ravail = avail_in;
+	if (uudecode->state == ST_IGNORE) {
+		used = avail_in;
+		goto finish;
+	}
 	if (uudecode->in_cnt) {
 		/*
 		 * If there is remaining data which is saved by
@@ -441,19 +474,32 @@ read_more:
 		uudecode->in_cnt = 0;
 	}
 	for (;used < avail_in; d += llen, used += llen) {
-		int l, body;
+		int64_t l, body;
 
 		b = d;
 		len = get_line(b, avail_in - used, &nl);
 		if (len < 0) {
 			/* Non-ascii character is found. */
+			if (uudecode->state == ST_FIND_HEAD &&
+			    (uudecode->total > 0 || total > 0)) {
+				uudecode->state = ST_IGNORE;
+				used = avail_in;
+				goto finish;
+			}
 			archive_set_error(&self->archive->archive,
 			    ARCHIVE_ERRNO_MISC,
 			    "Insufficient compressed data");
 			return (ARCHIVE_FATAL);
 		}
 		llen = len;
-		if (nl == 0) {
+		if ((nl == 0) && (uudecode->state != ST_UUEND)) {
+			if (total == 0 && ravail <= 0) {
+				/* There is nothing more to read, fail */
+				archive_set_error(&self->archive->archive,
+				    ARCHIVE_ERRNO_FILE_FORMAT,
+				    "Missing format data");
+				return (ARCHIVE_FATAL);
+			}
 			/*
 			 * Save remaining data which does not contain
 			 * NL('\n','\r').
@@ -463,7 +509,7 @@ read_more:
 				return (ARCHIVE_FATAL);
 			if (uudecode->in_buff != b)
 				memmove(uudecode->in_buff, b, len);
-			uudecode->in_cnt = len;
+			uudecode->in_cnt = (int)len;
 			if (total == 0) {
 				/* Do not return 0; it means end-of-file.
 				 * We should try to read bytes more. */
@@ -471,16 +517,22 @@ read_more:
 				    self->upstream, ravail);
 				goto read_more;
 			}
+			used += len;
 			break;
 		}
-		if (total + len * 2 > OUT_BUFF_SIZE)
-			break;
 		switch (uudecode->state) {
 		default:
 		case ST_FIND_HEAD:
-			if (len - nl > 13 && memcmp(b, "begin ", 6) == 0)
+			/* Do not read more than UUENCODE_BID_MAX_READ bytes */
+			if (total + len >= UUENCODE_BID_MAX_READ) {
+				archive_set_error(&self->archive->archive,
+				    ARCHIVE_ERRNO_FILE_FORMAT,
+				    "Invalid format data");
+				return (ARCHIVE_FATAL);
+			}
+			if (len - nl >= 11 && memcmp(b, "begin ", 6) == 0)
 				l = 6;
-			else if (len - nl > 18 &&
+			else if (len - nl >= 18 &&
 			    memcmp(b, "begin-base64 ", 13) == 0)
 				l = 13;
 			else
@@ -495,6 +547,8 @@ read_more:
 			}
 			break;
 		case ST_READ_UU:
+			if (total + len * 2 > OUT_BUFF_SIZE)
+				goto finish;
 			body = len - nl;
 			if (!uuchar[*b] || body <= 0) {
 				archive_set_error(&self->archive->archive,
@@ -502,7 +556,7 @@ read_more:
 				    "Insufficient compressed data");
 				return (ARCHIVE_FATAL);
 			}
-			/* Get length of undecoded bytes of curent line. */
+			/* Get length of undecoded bytes of current line. */
 			l = UUDECODE(*b++);
 			body--;
 			if (l > body) {
@@ -518,14 +572,13 @@ read_more:
 			while (l > 0) {
 				int n = 0;
 
-				if (l > 0) {
-					if (!uuchar[b[0]] || !uuchar[b[1]])
-						break;
-					n = UUDECODE(*b++) << 18;
-					n |= UUDECODE(*b++) << 12;
-					*out++ = n >> 16; total++;
-					--l;
-				}
+				if (!uuchar[b[0]] || !uuchar[b[1]])
+					break;
+				n = UUDECODE(*b++) << 18;
+				n |= UUDECODE(*b++) << 12;
+				*out++ = n >> 16; total++;
+				--l;
+
 				if (l > 0) {
 					if (!uuchar[b[0]])
 						break;
@@ -559,6 +612,8 @@ read_more:
 			}
 			break;
 		case ST_READ_BASE64:
+			if (total + len * 2 > OUT_BUFF_SIZE)
+				goto finish;
 			l = len - nl;
 			if (l >= 3 && b[0] == '=' && b[1] == '=' &&
 			    b[2] == '=') {
@@ -568,14 +623,13 @@ read_more:
 			while (l > 0) {
 				int n = 0;
 
-				if (l > 0) {
-					if (!base64[b[0]] || !base64[b[1]])
-						break;
-					n = base64num[*b++] << 18;
-					n |= base64num[*b++] << 12;
-					*out++ = n >> 16; total++;
-					l -= 2;
-				}
+				if (!base64[b[0]] || !base64[b[1]])
+					break;
+				n = base64num[*b++] << 18;
+				n |= base64num[*b++] << 12;
+				*out++ = n >> 16; total++;
+				l -= 2;
+
 				if (l > 0) {
 					if (*b == '=')
 						break;
@@ -604,8 +658,10 @@ read_more:
 			break;
 		}
 	}
-
-	__archive_read_filter_consume(self->upstream, ravail);
+finish:
+	if (ravail < avail_in)
+		used -= avail_in - ravail;
+	__archive_read_filter_consume(self->upstream, used);
 
 	*buff = uudecode->out_buff;
 	uudecode->total += total;