1/*	$NetBSD: cread.c,v 1.29 2023/06/14 00:28:55 rin Exp $	*/
2
3/*
4 * Copyright (c) 1996
5 *	Matthias Drochner.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 */
28
29/*
30 * Support for compressed bootfiles  (only read)
31 *
32 * - replaces open(), close(), read(), lseek().
33 * - original libsa open(), close(), read(), lseek() are called
34 *   as oopen(), oclose(), oread() resp. olseek().
35 * - compression parts stripped from zlib:gzio.c
36 */
37
38/* gzio.c -- IO on .gz files
39 * Copyright (C) 1995-1996 Jean-loup Gailly.
40 * For conditions of distribution and use, see copyright notice in zlib.h
41 */
42
43#include "stand.h"
44#ifdef _STANDALONE
45#include <lib/libkern/libkern.h>
46#include <lib/libz/libz.h>
47#else
48#include <string.h>
49#include <zlib.h>
50#endif
51
52#define EOF (-1) /* needed by compression code */
53
54#ifdef SAVE_MEMORY
55#define Z_BUFSIZE 1024
56#else
57#define Z_BUFSIZE 4096
58#endif
59
60static const int gz_magic[2] = {0x1f, 0x8b};	/* gzip magic header */
61
62/* gzip flag byte */
63#define ASCII_FLAG	0x01	/* bit 0 set: file probably ascii text */
64#define HEAD_CRC	0x02	/* bit 1 set: header CRC present */
65#define EXTRA_FIELD	0x04	/* bit 2 set: extra field present */
66#define ORIG_NAME	0x08	/* bit 3 set: original file name present */
67#define COMMENT		0x10	/* bit 4 set: file comment present */
68#define RESERVED	0xE0	/* bits 5..7: reserved */
69
70static struct sd {
71	z_stream	stream;
72	int		z_err;	/* error code for last stream operation */
73	int		z_eof;	/* set if end of input file */
74	int		fd;
75	unsigned char	*inbuf;	/* input buffer */
76	unsigned long	crc;	/* crc32 of uncompressed data */
77	int		compressed;	/* 1 if input file is a .gz file */
78} *ss[SOPEN_MAX];
79
80static int		get_byte(struct sd *);
81static unsigned long	getLong(struct sd *);
82static void		check_header(struct sd *);
83
84/* XXX - find suitable header file for these: */
85void	*zcalloc(void *, unsigned int, unsigned int);
86void	zcfree(void *, void *);
87void	zmemcpy(unsigned char *, unsigned char *, unsigned int);
88
89/*
90 * This is the double-loop version of LE CRC32 from if_ethersubr,
91 * lightly modified -- it is ~1KB smaller than libkern version with
92 * DYNAMIC_CRC_TABLE but too much slower especially on ancient poor CPUs.
93 */
94#ifndef ETHER_CRC_POLY_LE
95#define ETHER_CRC_POLY_LE	0xedb88320
96#endif
97uint32_t
98crc32(uint32_t crc, const uint8_t *const buf, size_t len)
99{
100#if defined(LIBSA_CREAD_NOCRC)
101	/* XXX provide a stub to avoid pulling a larger libkern version */
102	return crc;
103#else
104	uint32_t c, carry;
105	size_t i, j;
106
107	crc = 0xffffffffU ^ crc;
108	for (i = 0; i < len; i++) {
109		c = buf[i];
110		for (j = 0; j < 8; j++) {
111			carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
112			crc >>= 1;
113			c >>= 1;
114			if (carry) {
115				crc = (crc ^ ETHER_CRC_POLY_LE);
116			}
117		}
118	}
119	return (crc ^ 0xffffffffU);
120#endif /* defined(LIBSA_CREAD_NOCRC) */
121}
122
123/*
124 * compression utilities
125 */
126
127void *
128zcalloc(void *opaque, unsigned int items, unsigned int size)
129{
130
131	return alloc(items * size);
132}
133
134void
135zcfree(void *opaque, void *ptr)
136{
137
138	dealloc(ptr, 0); /* XXX works only with modified allocator */
139}
140
141void
142zmemcpy(unsigned char *dest, unsigned char *source, unsigned int len)
143{
144
145	memcpy(dest, source, len);
146}
147
148static int
149get_byte(struct sd *s)
150{
151	if (s->z_eof)
152		return EOF;
153
154	if (s->stream.avail_in == 0) {
155		int got;
156
157		errno = 0;
158		got = oread(s->fd, s->inbuf, Z_BUFSIZE);
159		if (got <= 0) {
160			s->z_eof = 1;
161			if (errno)
162				s->z_err = Z_ERRNO;
163			return EOF;
164		}
165		s->stream.avail_in = got;
166		s->stream.next_in = s->inbuf;
167	}
168	s->stream.avail_in--;
169	return *(s->stream.next_in)++;
170}
171
172static unsigned long
173getLong(struct sd *s)
174{
175	unsigned long x;
176	int c;
177
178	x  =  (unsigned long)get_byte(s);
179	x += ((unsigned long)get_byte(s)) << 8;
180	x += ((unsigned long)get_byte(s)) << 16;
181	c = get_byte(s);
182	if (c == EOF)
183		s->z_err = Z_DATA_ERROR;
184	x += ((unsigned long)c) << 24;
185	return x;
186}
187
188static void
189check_header(struct sd *s)
190{
191	int method; /* method byte */
192	int flags;  /* flags byte */
193	unsigned int len;
194	int c;
195
196	/* Check the gzip magic header */
197	for (len = 0; len < 2; len++) {
198		c = get_byte(s);
199		if (c == gz_magic[len])
200			continue;
201		if ((c == EOF) && (len == 0))  {
202			/*
203			 * We must not change s->compressed if we are at EOF;
204			 * we may have come to the end of a gzipped file and be
205			 * check to see if another gzipped file is concatenated
206			 * to this one. If one isn't, we still need to be able
207			 * to lseek on this file as a compressed file.
208			 */
209			return;
210		}
211		s->compressed = 0;
212		if (c != EOF) {
213			s->stream.avail_in++;
214			s->stream.next_in--;
215		}
216		s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
217		return;
218	}
219	s->compressed = 1;
220	method = get_byte(s);
221	flags = get_byte(s);
222	if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
223		s->z_err = Z_DATA_ERROR;
224		return;
225	}
226
227	/* Discard time, xflags and OS code: */
228	for (len = 0; len < 6; len++)
229		(void)get_byte(s);
230
231	if ((flags & EXTRA_FIELD) != 0) {
232		/* skip the extra field */
233		len  =  (unsigned int)get_byte(s);
234		len += ((unsigned int)get_byte(s)) << 8;
235		/* len is garbage if EOF but the loop below will quit anyway */
236		while (len-- != 0 && get_byte(s) != EOF)
237			/*void*/;
238	}
239	if ((flags & ORIG_NAME) != 0) {
240		/* skip the original file name */
241		while ((c = get_byte(s)) != 0 && c != EOF)
242			/*void*/;
243	}
244	if ((flags & COMMENT) != 0) {
245		/* skip the .gz file comment */
246		while ((c = get_byte(s)) != 0 && c != EOF)
247			/*void*/;
248	}
249	if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
250		for (len = 0; len < 2; len++)
251			(void)get_byte(s);
252	}
253	s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
254}
255
256/*
257 * new open(), close(), read(), lseek()
258 */
259
260int
261open(const char *fname, int mode)
262{
263	int fd;
264	struct sd *s = 0;
265
266	if (((fd = oopen(fname, mode)) == -1) || (mode != 0))
267		/* compression only for read */
268		return fd;
269
270	ss[fd] = s = alloc(sizeof(struct sd));
271	if (s == 0)
272		goto errout;
273	(void)memset(s, 0, sizeof(struct sd));
274
275	if (inflateInit2(&(s->stream), -15) != Z_OK)
276		goto errout;
277
278	s->stream.next_in = s->inbuf = (unsigned char *)alloc(Z_BUFSIZE);
279	if (s->inbuf == 0) {
280		inflateEnd(&(s->stream));
281		goto errout;
282	}
283
284	s->fd = fd;
285	check_header(s); /* skip the .gz header */
286	return fd;
287
288errout:
289	if (s != 0)
290		dealloc(s, sizeof(struct sd));
291	ss[fd] = NULL;
292	oclose(fd);
293	return -1;
294}
295
296int
297close(int fd)
298{
299	struct sd *s;
300
301#if !defined(LIBSA_NO_FD_CHECKING)
302	if ((unsigned int)fd >= SOPEN_MAX) {
303		errno = EBADF;
304		return -1;
305	}
306#endif
307
308	s = ss[fd];
309
310	if (s != NULL) {
311		inflateEnd(&(s->stream));
312
313		dealloc(s->inbuf, Z_BUFSIZE);
314		dealloc(s, sizeof(struct sd));
315	}
316
317	return oclose(fd);
318}
319
320ssize_t
321read(int fd, void *buf, size_t len)
322{
323	struct sd *s;
324#if !defined(LIBSA_CREAD_NOCRC)
325	unsigned char *start = buf; /* starting point for crc computation */
326#endif
327
328	s = ss[fd];
329
330	if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)
331		return -1;
332	if (s->z_err == Z_STREAM_END)
333		return 0;  /* EOF */
334
335	s->stream.next_out = buf;
336	s->stream.avail_out = len;
337
338	while (s->stream.avail_out != 0) {
339
340		if (s->compressed == 0) {
341			/* Copy first the lookahead bytes: */
342			unsigned int n = s->stream.avail_in;
343			if (n > s->stream.avail_out)
344				n = s->stream.avail_out;
345			if (n > 0) {
346				zmemcpy(s->stream.next_out,
347					s->stream.next_in, n);
348				s->stream.next_out  += n;
349				s->stream.next_in   += n;
350				s->stream.avail_out -= n;
351				s->stream.avail_in  -= n;
352			}
353			if (s->stream.avail_out > 0) {
354				int got;
355				got = oread(s->fd, s->stream.next_out,
356				            s->stream.avail_out);
357				if (got == -1)
358					return got;
359				s->stream.avail_out -= got;
360			}
361			return (int)(len - s->stream.avail_out);
362		}
363
364		if (s->stream.avail_in == 0 && !s->z_eof) {
365			int got;
366			errno = 0;
367			got = oread(fd, s->inbuf, Z_BUFSIZE);
368			if (got <= 0) {
369				s->z_eof = 1;
370				if (errno) {
371					s->z_err = Z_ERRNO;
372					break;
373				}
374			}
375			s->stream.avail_in = got;
376			s->stream.next_in = s->inbuf;
377		}
378
379		s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
380
381		if (s->z_err == Z_STREAM_END) {
382			uint32_t total_out;
383#if !defined(LIBSA_CREAD_NOCRC)
384			uint32_t crc;
385			/* Check CRC and original size */
386			s->crc = crc32(s->crc, start, (unsigned int)
387					(s->stream.next_out - start));
388			start = s->stream.next_out;
389			crc = getLong(s);
390#else
391			(void)getLong(s);
392#endif
393			total_out = getLong(s);
394
395			if (
396#if !defined(LIBSA_CREAD_NOCRC)
397			    crc != s->crc ||
398#endif
399			    total_out != s->stream.total_out) {
400
401				s->z_err = Z_DATA_ERROR;
402			} else {
403				/* Check for concatenated .gz files: */
404				check_header(s);
405				if (s->z_err == Z_OK) {
406					inflateReset(&(s->stream));
407#if !defined(LIBSA_CREAD_NOCRC)
408					s->crc = crc32(0L, Z_NULL, 0);
409#endif
410				}
411			}
412		}
413		if (s->z_err != Z_OK || s->z_eof)
414			break;
415	}
416
417#if !defined(LIBSA_CREAD_NOCRC)
418	s->crc = crc32(s->crc, start,
419	               (unsigned int)(s->stream.next_out - start));
420#endif
421
422	return (int)(len - s->stream.avail_out);
423}
424
425off_t
426lseek(int fd, off_t offset, int where)
427{
428	struct open_file *f;
429	struct sd *s;
430
431#if !defined(LIBSA_NO_FD_CHECKING)
432	if ((unsigned int)fd >= SOPEN_MAX) {
433		errno = EBADF;
434		return -1;
435	}
436#endif
437	f = &files[fd];
438
439	if ((f->f_flags & F_READ) == 0)
440		return olseek(fd, offset, where);
441
442	s = ss[fd];
443
444	if(s->compressed == 0) {
445		off_t res = olseek(fd, offset, where);
446		if (res != (off_t)-1) {
447			/* make sure the lookahead buffer is invalid */
448			s->stream.avail_in = 0;
449		}
450		return res;
451	}
452
453	switch(where) {
454	case SEEK_CUR:
455		offset += s->stream.total_out;
456		/* FALLTHROUGH */
457	case SEEK_SET:
458		/* if seek backwards, simply start from the beginning */
459		if (offset < s->stream.total_out) {
460			off_t res;
461			void *sav_inbuf;
462
463			res = olseek(fd, 0, SEEK_SET);
464			if(res == (off_t)-1)
465				return res;
466			/* ??? perhaps fallback to close / open */
467
468			inflateEnd(&(s->stream));
469
470			sav_inbuf = s->inbuf; /* don't allocate again */
471			(void)memset(s, 0, sizeof(struct sd));
472			/* this resets total_out to 0! */
473
474			inflateInit2(&(s->stream), -15);
475			s->stream.next_in = s->inbuf = sav_inbuf;
476
477			s->fd = fd;
478			check_header(s); /* skip the .gz header */
479		}
480
481		/* to seek forwards, throw away data */
482		if (offset > s->stream.total_out) {
483			off_t toskip = offset - s->stream.total_out;
484
485			while (toskip > 0) {
486#define DUMMYBUFSIZE 256
487				char dummybuf[DUMMYBUFSIZE];
488				off_t len = toskip;
489
490				if (len > DUMMYBUFSIZE)
491					len = DUMMYBUFSIZE;
492				if (read(fd, dummybuf, len) != len) {
493					errno = EOFFSET;
494					return (off_t)-1;
495				}
496				toskip -= len;
497			}
498		}
499#ifdef DEBUG
500		if (offset != s->stream.total_out)
501			panic("lseek compressed");
502#endif
503		return offset;
504	case SEEK_END:
505		errno = EOFFSET;
506		break;
507	default:
508		errno = EINVAL;
509		break;
510	}
511
512	return (off_t)-1;
513}
514