1/*-
2 * Copyright (c) 2009-2011 Michihiro NAKAJIMA
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(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "archive_platform.h"
27__FBSDID("$FreeBSD$");
28
29#ifdef HAVE_ERRNO_H
30#include <errno.h>
31#endif
32#ifdef HAVE_STDLIB_H
33#include <stdlib.h>
34#endif
35#ifdef HAVE_STRING_H
36#include <string.h>
37#endif
38
39#include "archive.h"
40#include "archive_private.h"
41#include "archive_read_private.h"
42
43/* Maximum lookahead during bid phase */
44#define UUENCODE_BID_MAX_READ 128*1024 /* in bytes */
45
46struct uudecode {
47	int64_t		 total;
48	unsigned char	*in_buff;
49#define IN_BUFF_SIZE	(1024)
50	int		 in_cnt;
51	size_t		 in_allocated;
52	unsigned char	*out_buff;
53#define OUT_BUFF_SIZE	(64 * 1024)
54	int		 state;
55#define ST_FIND_HEAD	0
56#define ST_READ_UU	1
57#define ST_UUEND	2
58#define ST_READ_BASE64	3
59#define ST_IGNORE	4
60};
61
62static int	uudecode_bidder_bid(struct archive_read_filter_bidder *,
63		    struct archive_read_filter *filter);
64static int	uudecode_bidder_init(struct archive_read_filter *);
65
66static ssize_t	uudecode_filter_read(struct archive_read_filter *,
67		    const void **);
68static int	uudecode_filter_close(struct archive_read_filter *);
69
70#if ARCHIVE_VERSION_NUMBER < 4000000
71/* Deprecated; remove in libarchive 4.0 */
72int
73archive_read_support_compression_uu(struct archive *a)
74{
75	return archive_read_support_filter_uu(a);
76}
77#endif
78
79int
80archive_read_support_filter_uu(struct archive *_a)
81{
82	struct archive_read *a = (struct archive_read *)_a;
83	struct archive_read_filter_bidder *bidder;
84
85	archive_check_magic(_a, ARCHIVE_READ_MAGIC,
86	    ARCHIVE_STATE_NEW, "archive_read_support_filter_uu");
87
88	if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK)
89		return (ARCHIVE_FATAL);
90
91	bidder->data = NULL;
92	bidder->name = "uu";
93	bidder->bid = uudecode_bidder_bid;
94	bidder->init = uudecode_bidder_init;
95	bidder->options = NULL;
96	bidder->free = NULL;
97	return (ARCHIVE_OK);
98}
99
100static const unsigned char ascii[256] = {
101	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '\n', 0, 0, '\r', 0, 0, /* 00 - 0F */
102	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
103	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */
104	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 30 - 3F */
105	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */
106	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */
107	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */
108	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* 70 - 7F */
109	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
110	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
111	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
112	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
113	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
114	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
115	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
116	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */
117};
118
119static const unsigned char uuchar[256] = {
120	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */
121	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
122	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */
123	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 30 - 3F */
124	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */
125	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */
126	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F */
127	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 70 - 7F */
128	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
129	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
130	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
131	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
132	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
133	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
134	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
135	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */
136};
137
138static const unsigned char base64[256] = {
139	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */
140	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
141	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, /* 20 - 2F */
142	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 30 - 3F */
143	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */
144	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 50 - 5F */
145	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */
146	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 70 - 7F */
147	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
148	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
149	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
150	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
151	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
152	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
153	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
154	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */
155};
156
157static const int base64num[128] = {
158	 0,  0,  0,  0,  0,  0,  0,  0,
159	 0,  0,  0,  0,  0,  0,  0,  0, /* 00 - 0F */
160	 0,  0,  0,  0,  0,  0,  0,  0,
161	 0,  0,  0,  0,  0,  0,  0,  0, /* 10 - 1F */
162	 0,  0,  0,  0,  0,  0,  0,  0,
163	 0,  0,  0, 62,  0,  0,  0, 63, /* 20 - 2F */
164	52, 53, 54, 55, 56, 57, 58, 59,
165	60, 61,  0,  0,  0,  0,  0,  0, /* 30 - 3F */
166	 0,  0,  1,  2,  3,  4,  5,  6,
167	 7,  8,  9, 10, 11, 12, 13, 14, /* 40 - 4F */
168	15, 16, 17, 18, 19, 20, 21, 22,
169	23, 24, 25,  0,  0,  0,  0,  0, /* 50 - 5F */
170	 0, 26, 27, 28, 29, 30, 31, 32,
171	33, 34, 35, 36, 37, 38, 39, 40, /* 60 - 6F */
172	41, 42, 43, 44, 45, 46, 47, 48,
173	49, 50, 51,  0,  0,  0,  0,  0, /* 70 - 7F */
174};
175
176static ssize_t
177get_line(const unsigned char *b, ssize_t avail, ssize_t *nlsize)
178{
179	ssize_t len;
180
181	len = 0;
182	while (len < avail) {
183		switch (ascii[*b]) {
184		case 0:	/* Non-ascii character or control character. */
185			if (nlsize != NULL)
186				*nlsize = 0;
187			return (-1);
188		case '\r':
189			if (avail-len > 1 && b[1] == '\n') {
190				if (nlsize != NULL)
191					*nlsize = 2;
192				return (len+2);
193			}
194			/* FALL THROUGH */
195		case '\n':
196			if (nlsize != NULL)
197				*nlsize = 1;
198			return (len+1);
199		case 1:
200			b++;
201			len++;
202			break;
203		}
204	}
205	if (nlsize != NULL)
206		*nlsize = 0;
207	return (avail);
208}
209
210static ssize_t
211bid_get_line(struct archive_read_filter *filter,
212    const unsigned char **b, ssize_t *avail, ssize_t *ravail,
213    ssize_t *nl, size_t* nbytes_read)
214{
215	ssize_t len;
216	int quit;
217
218	quit = 0;
219	if (*avail == 0) {
220		*nl = 0;
221		len = 0;
222	} else
223		len = get_line(*b, *avail, nl);
224
225	/*
226	 * Read bytes more while it does not reach the end of line.
227	 */
228	while (*nl == 0 && len == *avail && !quit &&
229	    *nbytes_read < UUENCODE_BID_MAX_READ) {
230		ssize_t diff = *ravail - *avail;
231		size_t nbytes_req = (*ravail+1023) & ~1023U;
232		ssize_t tested;
233
234		/* Increase reading bytes if it is not enough to at least
235		 * new two lines. */
236		if (nbytes_req < (size_t)*ravail + 160)
237			nbytes_req <<= 1;
238
239		*b = __archive_read_filter_ahead(filter, nbytes_req, avail);
240		if (*b == NULL) {
241			if (*ravail >= *avail)
242				return (0);
243			/* Reading bytes reaches the end of a stream. */
244			*b = __archive_read_filter_ahead(filter, *avail, avail);
245			quit = 1;
246		}
247		*nbytes_read = *avail;
248		*ravail = *avail;
249		*b += diff;
250		*avail -= diff;
251		tested = len;/* Skip some bytes we already determinated. */
252		len = get_line(*b + tested, *avail - tested, nl);
253		if (len >= 0)
254			len += tested;
255	}
256	return (len);
257}
258
259#define UUDECODE(c) (((c) - 0x20) & 0x3f)
260
261static int
262uudecode_bidder_bid(struct archive_read_filter_bidder *self,
263    struct archive_read_filter *filter)
264{
265	const unsigned char *b;
266	ssize_t avail, ravail;
267	ssize_t len, nl;
268	int l;
269	int firstline;
270	size_t nbytes_read;
271
272	(void)self; /* UNUSED */
273
274	b = __archive_read_filter_ahead(filter, 1, &avail);
275	if (b == NULL)
276		return (0);
277
278	firstline = 20;
279	ravail = avail;
280	nbytes_read = avail;
281	for (;;) {
282		len = bid_get_line(filter, &b, &avail, &ravail, &nl, &nbytes_read);
283		if (len < 0 || nl == 0)
284			return (0); /* No match found. */
285		if (len - nl >= 11 && memcmp(b, "begin ", 6) == 0)
286			l = 6;
287		else if (len -nl >= 18 && memcmp(b, "begin-base64 ", 13) == 0)
288			l = 13;
289		else
290			l = 0;
291
292		if (l > 0 && (b[l] < '0' || b[l] > '7' ||
293		    b[l+1] < '0' || b[l+1] > '7' ||
294		    b[l+2] < '0' || b[l+2] > '7' || b[l+3] != ' '))
295			l = 0;
296
297		b += len;
298		avail -= len;
299		if (l)
300			break;
301		firstline = 0;
302
303		/* Do not read more than UUENCODE_BID_MAX_READ bytes */
304		if (nbytes_read >= UUENCODE_BID_MAX_READ)
305			return (0);
306	}
307	if (!avail)
308		return (0);
309	len = bid_get_line(filter, &b, &avail, &ravail, &nl, &nbytes_read);
310	if (len < 0 || nl == 0)
311		return (0);/* There are non-ascii characters. */
312	avail -= len;
313
314	if (l == 6) {
315		/* "begin " */
316		if (!uuchar[*b])
317			return (0);
318		/* Get a length of decoded bytes. */
319		l = UUDECODE(*b++); len--;
320		if (l > 45)
321			/* Normally, maximum length is 45(character 'M'). */
322			return (0);
323		if (l > len - nl)
324			return (0); /* Line too short. */
325		while (l) {
326			if (!uuchar[*b++])
327				return (0);
328			--len;
329			--l;
330		}
331		if (len-nl == 1 &&
332		    (uuchar[*b] ||		 /* Check sum. */
333		     (*b >= 'a' && *b <= 'z'))) {/* Padding data(MINIX). */
334			++b;
335			--len;
336		}
337		b += nl;
338		if (avail && uuchar[*b])
339			return (firstline+30);
340	} else if (l == 13) {
341		/* "begin-base64 " */
342		while (len-nl > 0) {
343			if (!base64[*b++])
344				return (0);
345			--len;
346		}
347		b += nl;
348
349		if (avail >= 5 && memcmp(b, "====\n", 5) == 0)
350			return (firstline+40);
351		if (avail >= 6 && memcmp(b, "====\r\n", 6) == 0)
352			return (firstline+40);
353		if (avail > 0 && base64[*b])
354			return (firstline+30);
355	}
356
357	return (0);
358}
359
360static int
361uudecode_bidder_init(struct archive_read_filter *self)
362{
363	struct uudecode   *uudecode;
364	void *out_buff;
365	void *in_buff;
366
367	self->code = ARCHIVE_FILTER_UU;
368	self->name = "uu";
369	self->read = uudecode_filter_read;
370	self->skip = NULL; /* not supported */
371	self->close = uudecode_filter_close;
372
373	uudecode = (struct uudecode *)calloc(sizeof(*uudecode), 1);
374	out_buff = malloc(OUT_BUFF_SIZE);
375	in_buff = malloc(IN_BUFF_SIZE);
376	if (uudecode == NULL || out_buff == NULL || in_buff == NULL) {
377		archive_set_error(&self->archive->archive, ENOMEM,
378		    "Can't allocate data for uudecode");
379		free(uudecode);
380		free(out_buff);
381		free(in_buff);
382		return (ARCHIVE_FATAL);
383	}
384
385	self->data = uudecode;
386	uudecode->in_buff = in_buff;
387	uudecode->in_cnt = 0;
388	uudecode->in_allocated = IN_BUFF_SIZE;
389	uudecode->out_buff = out_buff;
390	uudecode->state = ST_FIND_HEAD;
391
392	return (ARCHIVE_OK);
393}
394
395static int
396ensure_in_buff_size(struct archive_read_filter *self,
397    struct uudecode *uudecode, size_t size)
398{
399
400	if (size > uudecode->in_allocated) {
401		unsigned char *ptr;
402		size_t newsize;
403
404		/*
405		 * Calculate a new buffer size for in_buff.
406		 * Increase its value until it has enough size we need.
407		 */
408		newsize = uudecode->in_allocated;
409		do {
410			if (newsize < IN_BUFF_SIZE*32)
411				newsize <<= 1;
412			else
413				newsize += IN_BUFF_SIZE;
414		} while (size > newsize);
415		/* Allocate the new buffer. */
416		ptr = malloc(newsize);
417		if (ptr == NULL) {
418			free(ptr);
419			archive_set_error(&self->archive->archive,
420			    ENOMEM,
421    			    "Can't allocate data for uudecode");
422			return (ARCHIVE_FATAL);
423		}
424		/* Move the remaining data in in_buff into the new buffer. */
425		if (uudecode->in_cnt)
426			memmove(ptr, uudecode->in_buff, uudecode->in_cnt);
427		/* Replace in_buff with the new buffer. */
428		free(uudecode->in_buff);
429		uudecode->in_buff = ptr;
430		uudecode->in_allocated = newsize;
431	}
432	return (ARCHIVE_OK);
433}
434
435static ssize_t
436uudecode_filter_read(struct archive_read_filter *self, const void **buff)
437{
438	struct uudecode *uudecode;
439	const unsigned char *b, *d;
440	unsigned char *out;
441	ssize_t avail_in, ravail;
442	ssize_t used;
443	ssize_t total;
444	ssize_t len, llen, nl;
445
446	uudecode = (struct uudecode *)self->data;
447
448read_more:
449	d = __archive_read_filter_ahead(self->upstream, 1, &avail_in);
450	if (d == NULL && avail_in < 0)
451		return (ARCHIVE_FATAL);
452	/* Quiet a code analyzer; make sure avail_in must be zero
453	 * when d is NULL. */
454	if (d == NULL)
455		avail_in = 0;
456	used = 0;
457	total = 0;
458	out = uudecode->out_buff;
459	ravail = avail_in;
460	if (uudecode->state == ST_IGNORE) {
461		used = avail_in;
462		goto finish;
463	}
464	if (uudecode->in_cnt) {
465		/*
466		 * If there is remaining data which is saved by
467		 * previous calling, use it first.
468		 */
469		if (ensure_in_buff_size(self, uudecode,
470		    avail_in + uudecode->in_cnt) != ARCHIVE_OK)
471			return (ARCHIVE_FATAL);
472		memcpy(uudecode->in_buff + uudecode->in_cnt,
473		    d, avail_in);
474		d = uudecode->in_buff;
475		avail_in += uudecode->in_cnt;
476		uudecode->in_cnt = 0;
477	}
478	for (;used < avail_in; d += llen, used += llen) {
479		int64_t l, body;
480
481		b = d;
482		len = get_line(b, avail_in - used, &nl);
483		if (len < 0) {
484			/* Non-ascii character is found. */
485			if (uudecode->state == ST_FIND_HEAD &&
486			    (uudecode->total > 0 || total > 0)) {
487				uudecode->state = ST_IGNORE;
488				used = avail_in;
489				goto finish;
490			}
491			archive_set_error(&self->archive->archive,
492			    ARCHIVE_ERRNO_MISC,
493			    "Insufficient compressed data");
494			return (ARCHIVE_FATAL);
495		}
496		llen = len;
497		if ((nl == 0) && (uudecode->state != ST_UUEND)) {
498			if (total == 0 && ravail <= 0) {
499				/* There is nothing more to read, fail */
500				archive_set_error(&self->archive->archive,
501				    ARCHIVE_ERRNO_FILE_FORMAT,
502				    "Missing format data");
503				return (ARCHIVE_FATAL);
504			}
505			/*
506			 * Save remaining data which does not contain
507			 * NL('\n','\r').
508			 */
509			if (ensure_in_buff_size(self, uudecode, len)
510			    != ARCHIVE_OK)
511				return (ARCHIVE_FATAL);
512			if (uudecode->in_buff != b)
513				memmove(uudecode->in_buff, b, len);
514			uudecode->in_cnt = (int)len;
515			if (total == 0) {
516				/* Do not return 0; it means end-of-file.
517				 * We should try to read bytes more. */
518				__archive_read_filter_consume(
519				    self->upstream, ravail);
520				goto read_more;
521			}
522			used += len;
523			break;
524		}
525		switch (uudecode->state) {
526		default:
527		case ST_FIND_HEAD:
528			/* Do not read more than UUENCODE_BID_MAX_READ bytes */
529			if (total + len >= UUENCODE_BID_MAX_READ) {
530				archive_set_error(&self->archive->archive,
531				    ARCHIVE_ERRNO_FILE_FORMAT,
532				    "Invalid format data");
533				return (ARCHIVE_FATAL);
534			}
535			if (len - nl >= 11 && memcmp(b, "begin ", 6) == 0)
536				l = 6;
537			else if (len - nl >= 18 &&
538			    memcmp(b, "begin-base64 ", 13) == 0)
539				l = 13;
540			else
541				l = 0;
542			if (l != 0 && b[l] >= '0' && b[l] <= '7' &&
543			    b[l+1] >= '0' && b[l+1] <= '7' &&
544			    b[l+2] >= '0' && b[l+2] <= '7' && b[l+3] == ' ') {
545				if (l == 6)
546					uudecode->state = ST_READ_UU;
547				else
548					uudecode->state = ST_READ_BASE64;
549			}
550			break;
551		case ST_READ_UU:
552			if (total + len * 2 > OUT_BUFF_SIZE)
553				goto finish;
554			body = len - nl;
555			if (!uuchar[*b] || body <= 0) {
556				archive_set_error(&self->archive->archive,
557				    ARCHIVE_ERRNO_MISC,
558				    "Insufficient compressed data");
559				return (ARCHIVE_FATAL);
560			}
561			/* Get length of undecoded bytes of current line. */
562			l = UUDECODE(*b++);
563			body--;
564			if (l > body) {
565				archive_set_error(&self->archive->archive,
566				    ARCHIVE_ERRNO_MISC,
567				    "Insufficient compressed data");
568				return (ARCHIVE_FATAL);
569			}
570			if (l == 0) {
571				uudecode->state = ST_UUEND;
572				break;
573			}
574			while (l > 0) {
575				int n = 0;
576
577				if (l > 0) {
578					if (!uuchar[b[0]] || !uuchar[b[1]])
579						break;
580					n = UUDECODE(*b++) << 18;
581					n |= UUDECODE(*b++) << 12;
582					*out++ = n >> 16; total++;
583					--l;
584				}
585				if (l > 0) {
586					if (!uuchar[b[0]])
587						break;
588					n |= UUDECODE(*b++) << 6;
589					*out++ = (n >> 8) & 0xFF; total++;
590					--l;
591				}
592				if (l > 0) {
593					if (!uuchar[b[0]])
594						break;
595					n |= UUDECODE(*b++);
596					*out++ = n & 0xFF; total++;
597					--l;
598				}
599			}
600			if (l) {
601				archive_set_error(&self->archive->archive,
602				    ARCHIVE_ERRNO_MISC,
603				    "Insufficient compressed data");
604				return (ARCHIVE_FATAL);
605			}
606			break;
607		case ST_UUEND:
608			if (len - nl == 3 && memcmp(b, "end ", 3) == 0)
609				uudecode->state = ST_FIND_HEAD;
610			else {
611				archive_set_error(&self->archive->archive,
612				    ARCHIVE_ERRNO_MISC,
613				    "Insufficient compressed data");
614				return (ARCHIVE_FATAL);
615			}
616			break;
617		case ST_READ_BASE64:
618			if (total + len * 2 > OUT_BUFF_SIZE)
619				goto finish;
620			l = len - nl;
621			if (l >= 3 && b[0] == '=' && b[1] == '=' &&
622			    b[2] == '=') {
623				uudecode->state = ST_FIND_HEAD;
624				break;
625			}
626			while (l > 0) {
627				int n = 0;
628
629				if (l > 0) {
630					if (!base64[b[0]] || !base64[b[1]])
631						break;
632					n = base64num[*b++] << 18;
633					n |= base64num[*b++] << 12;
634					*out++ = n >> 16; total++;
635					l -= 2;
636				}
637				if (l > 0) {
638					if (*b == '=')
639						break;
640					if (!base64[*b])
641						break;
642					n |= base64num[*b++] << 6;
643					*out++ = (n >> 8) & 0xFF; total++;
644					--l;
645				}
646				if (l > 0) {
647					if (*b == '=')
648						break;
649					if (!base64[*b])
650						break;
651					n |= base64num[*b++];
652					*out++ = n & 0xFF; total++;
653					--l;
654				}
655			}
656			if (l && *b != '=') {
657				archive_set_error(&self->archive->archive,
658				    ARCHIVE_ERRNO_MISC,
659				    "Insufficient compressed data");
660				return (ARCHIVE_FATAL);
661			}
662			break;
663		}
664	}
665finish:
666	if (ravail < avail_in)
667		used -= avail_in - ravail;
668	__archive_read_filter_consume(self->upstream, used);
669
670	*buff = uudecode->out_buff;
671	uudecode->total += total;
672	return (total);
673}
674
675static int
676uudecode_filter_close(struct archive_read_filter *self)
677{
678	struct uudecode *uudecode;
679
680	uudecode = (struct uudecode *)self->data;
681	free(uudecode->in_buff);
682	free(uudecode->out_buff);
683	free(uudecode);
684
685	return (ARCHIVE_OK);
686}
687
688