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