Home | History | Annotate | Line # | Download | only in libsa
cread.c revision 1.23 
      1 /*	$NetBSD: cread.c,v 1.23 2009/03/25 18:41:06 tls 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 
     60 static 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 
     70 static 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 
     80 static int		get_byte(struct sd *);
     81 static unsigned long	getLong(struct sd *);
     82 static void		check_header(struct sd *);
     83 
     84 /* XXX - find suitable header file for these: */
     85 void	*zcalloc(void *, unsigned int, unsigned int);
     86 void	zcfree(void *, void *);
     87 void	zmemcpy(unsigned char *, unsigned char *, unsigned int);
     88 
     89 /*
     90  * The libkern version of this function uses an 8K set of tables.
     91  * This is the double-loop version of LE CRC32 from if_ethersubr,
     92  * lightly modified -- it is 200 bytes smaller than the version using
     93  * a 4-bit table and at least 8K smaller than the libkern version.
     94  */
     95 #ifndef ETHER_CRC_POLY_LE
     96 #define ETHER_CRC_POLY_LE	0xedb88320
     97 #endif
     98 uint32_t
     99 crc32(uint32_t crc, const uint8_t *const buf, size_t len)
    100 {
    101 	uint32_t c, carry;
    102 	size_t i, j;
    103 
    104 	crc = 0xffffffffU ^ crc;
    105 	for (i = 0; i < len; i++) {
    106 	    c = buf[i];
    107 	    for (j = 0; j < 8; j++) {
    108 		carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
    109 		crc >>= 1;
    110 		c >>= 1;
    111 		if (carry) {
    112 			crc = (crc ^ ETHER_CRC_POLY_LE);
    113 		}
    114 	    }
    115 	}
    116 	return (crc ^ 0xffffffffU);
    117 }
    118 
    119 /*
    120  * compression utilities
    121  */
    122 
    123 void *
    124 zcalloc(void *opaque, unsigned int items, unsigned int size)
    125 {
    126 
    127 	return alloc(items * size);
    128 }
    129 
    130 void
    131 zcfree(void *opaque, void *ptr)
    132 {
    133 
    134 	dealloc(ptr, 0); /* XXX works only with modified allocator */
    135 }
    136 
    137 void
    138 zmemcpy(unsigned char *dest, unsigned char *source, unsigned int len)
    139 {
    140 
    141 	memcpy(dest, source, len);
    142 }
    143 
    144 static int
    145 get_byte(struct sd *s)
    146 {
    147 	if (s->z_eof)
    148 		return EOF;
    149 
    150 	if (s->stream.avail_in == 0) {
    151 		int got;
    152 
    153 		errno = 0;
    154 		got = oread(s->fd, s->inbuf, Z_BUFSIZE);
    155 		if (got <= 0) {
    156 			s->z_eof = 1;
    157 			if (errno)
    158 				s->z_err = Z_ERRNO;
    159 			return EOF;
    160 		}
    161 		s->stream.avail_in = got;
    162 		s->stream.next_in = s->inbuf;
    163 	}
    164 	s->stream.avail_in--;
    165 	return *(s->stream.next_in)++;
    166 }
    167 
    168 static unsigned long
    169 getLong(struct sd *s)
    170 {
    171 	unsigned long x;
    172 	int c;
    173 
    174 	x  =  (unsigned long)get_byte(s);
    175 	x += ((unsigned long)get_byte(s)) << 8;
    176 	x += ((unsigned long)get_byte(s)) << 16;
    177 	c = get_byte(s);
    178 	if (c == EOF)
    179 		s->z_err = Z_DATA_ERROR;
    180 	x += ((unsigned long)c) << 24;
    181 	return x;
    182 }
    183 
    184 static void
    185 check_header(struct sd *s)
    186 {
    187 	int method; /* method byte */
    188 	int flags;  /* flags byte */
    189 	unsigned int len;
    190 	int c;
    191 
    192 	/* Check the gzip magic header */
    193 	for (len = 0; len < 2; len++) {
    194 		c = get_byte(s);
    195 		if (c == gz_magic[len])
    196 			continue;
    197 		if ((c == EOF) && (len == 0))  {
    198 			/*
    199 			 * We must not change s->compressed if we are at EOF;
    200 			 * we may have come to the end of a gzipped file and be
    201 			 * check to see if another gzipped file is concatenated
    202 			 * to this one. If one isn't, we still need to be able
    203 			 * to lseek on this file as a compressed file.
    204 			 */
    205 			return;
    206 		}
    207 		s->compressed = 0;
    208 		if (c != EOF) {
    209 			s->stream.avail_in++;
    210 			s->stream.next_in--;
    211 		}
    212 		s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
    213 		return;
    214 	}
    215 	s->compressed = 1;
    216 	method = get_byte(s);
    217 	flags = get_byte(s);
    218 	if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
    219 		s->z_err = Z_DATA_ERROR;
    220 		return;
    221 	}
    222 
    223 	/* Discard time, xflags and OS code: */
    224 	for (len = 0; len < 6; len++)
    225 		(void)get_byte(s);
    226 
    227 	if ((flags & EXTRA_FIELD) != 0) {
    228 		/* skip the extra field */
    229 		len  =  (unsigned int)get_byte(s);
    230 		len += ((unsigned int)get_byte(s)) << 8;
    231 		/* len is garbage if EOF but the loop below will quit anyway */
    232 		while (len-- != 0 && get_byte(s) != EOF)
    233 			/*void*/;
    234 	}
    235 	if ((flags & ORIG_NAME) != 0) {
    236 		/* skip the original file name */
    237 		while ((c = get_byte(s)) != 0 && c != EOF)
    238 			/*void*/;
    239 	}
    240 	if ((flags & COMMENT) != 0) {
    241 		/* skip the .gz file comment */
    242 		while ((c = get_byte(s)) != 0 && c != EOF)
    243 			/*void*/;
    244 	}
    245 	if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
    246 		for (len = 0; len < 2; len++)
    247 			(void)get_byte(s);
    248 	}
    249 	s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
    250 }
    251 
    252 /*
    253  * new open(), close(), read(), lseek()
    254  */
    255 
    256 int
    257 open(const char *fname, int mode)
    258 {
    259 	int fd;
    260 	struct sd *s = 0;
    261 
    262 	if (((fd = oopen(fname, mode)) == -1) || (mode != 0))
    263 		/* compression only for read */
    264 		return fd;
    265 
    266 	ss[fd] = s = alloc(sizeof(struct sd));
    267 	if (s == 0)
    268 		goto errout;
    269 	(void)memset(s, 0, sizeof(struct sd));
    270 
    271 	if (inflateInit2(&(s->stream), -15) != Z_OK)
    272 		goto errout;
    273 
    274 	s->stream.next_in = s->inbuf = (unsigned char *)alloc(Z_BUFSIZE);
    275 	if (s->inbuf == 0) {
    276 		inflateEnd(&(s->stream));
    277 		goto errout;
    278 	}
    279 
    280 	s->fd = fd;
    281 	check_header(s); /* skip the .gz header */
    282 	return fd;
    283 
    284 errout:
    285 	if (s != 0)
    286 		dealloc(s, sizeof(struct sd));
    287 	oclose(fd);
    288 	return -1;
    289 }
    290 
    291 int
    292 close(int fd)
    293 {
    294 	struct open_file *f;
    295 	struct sd *s;
    296 
    297 #if !defined(LIBSA_NO_FD_CHECKING)
    298 	if ((unsigned int)fd >= SOPEN_MAX) {
    299 		errno = EBADF;
    300 		return -1;
    301 	}
    302 #endif
    303 	f = &files[fd];
    304 
    305 	if ((f->f_flags & F_READ) == 0)
    306 		return oclose(fd);
    307 
    308 	s = ss[fd];
    309 
    310 	inflateEnd(&(s->stream));
    311 
    312 	dealloc(s->inbuf, Z_BUFSIZE);
    313 	dealloc(s, sizeof(struct sd));
    314 
    315 	return oclose(fd);
    316 }
    317 
    318 ssize_t
    319 read(int fd, void *buf, size_t len)
    320 {
    321 	struct sd *s;
    322 	unsigned char *start = buf; /* starting point for crc computation */
    323 
    324 	s = ss[fd];
    325 
    326 	if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)
    327 		return -1;
    328 	if (s->z_err == Z_STREAM_END)
    329 		return 0;  /* EOF */
    330 
    331 	s->stream.next_out = buf;
    332 	s->stream.avail_out = len;
    333 
    334 	while (s->stream.avail_out != 0) {
    335 
    336 		if (s->compressed == 0) {
    337 			/* Copy first the lookahead bytes: */
    338 			unsigned int n = s->stream.avail_in;
    339 			if (n > s->stream.avail_out)
    340 				n = s->stream.avail_out;
    341 			if (n > 0) {
    342 				zmemcpy(s->stream.next_out,
    343 					s->stream.next_in, n);
    344 				s->stream.next_out  += n;
    345 				s->stream.next_in   += n;
    346 				s->stream.avail_out -= n;
    347 				s->stream.avail_in  -= n;
    348 			}
    349 			if (s->stream.avail_out > 0) {
    350 				int got;
    351 				got = oread(s->fd, s->stream.next_out,
    352 				            s->stream.avail_out);
    353 				if (got == -1)
    354 					return got;
    355 				s->stream.avail_out -= got;
    356 			}
    357 			return (int)(len - s->stream.avail_out);
    358 		}
    359 
    360 		if (s->stream.avail_in == 0 && !s->z_eof) {
    361 			int got;
    362 			errno = 0;
    363 			got = oread(fd, s->inbuf, Z_BUFSIZE);
    364 			if (got <= 0) {
    365 				s->z_eof = 1;
    366 				if (errno) {
    367 					s->z_err = Z_ERRNO;
    368 					break;
    369 				}
    370 			}
    371 			s->stream.avail_in = got;
    372 			s->stream.next_in = s->inbuf;
    373 		}
    374 
    375 		s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
    376 
    377 		if (s->z_err == Z_STREAM_END) {
    378 			/* Check CRC and original size */
    379 			s->crc = crc32(s->crc, start, (unsigned int)
    380 					(s->stream.next_out - start));
    381 			start = s->stream.next_out;
    382 
    383 			if (getLong(s) != s->crc ||
    384 			    getLong(s) != s->stream.total_out) {
    385 
    386 				s->z_err = Z_DATA_ERROR;
    387 			} else {
    388 				/* Check for concatenated .gz files: */
    389 				check_header(s);
    390 				if (s->z_err == Z_OK) {
    391 					inflateReset(&(s->stream));
    392 					s->crc = crc32(0L, Z_NULL, 0);
    393 				}
    394 			}
    395 		}
    396 		if (s->z_err != Z_OK || s->z_eof)
    397 			break;
    398 	}
    399 
    400 	s->crc = crc32(s->crc, start,
    401 	               (unsigned int)(s->stream.next_out - start));
    402 
    403 	return (int)(len - s->stream.avail_out);
    404 }
    405 
    406 off_t
    407 lseek(int fd, off_t offset, int where)
    408 {
    409 	struct open_file *f;
    410 	struct sd *s;
    411 
    412 #if !defined(LIBSA_NO_FD_CHECKING)
    413 	if ((unsigned int)fd >= SOPEN_MAX) {
    414 		errno = EBADF;
    415 		return -1;
    416 	}
    417 #endif
    418 	f = &files[fd];
    419 
    420 	if ((f->f_flags & F_READ) == 0)
    421 		return olseek(fd, offset, where);
    422 
    423 	s = ss[fd];
    424 
    425 	if(s->compressed == 0) {
    426 		off_t res = olseek(fd, offset, where);
    427 		if (res != (off_t)-1) {
    428 			/* make sure the lookahead buffer is invalid */
    429 			s->stream.avail_in = 0;
    430 		}
    431 		return res;
    432 	}
    433 
    434 	switch(where) {
    435 	case SEEK_CUR:
    436 		offset += s->stream.total_out;
    437 	case SEEK_SET:
    438 		/* if seek backwards, simply start from the beginning */
    439 		if (offset < s->stream.total_out) {
    440 			off_t res;
    441 			void *sav_inbuf;
    442 
    443 			res = olseek(fd, 0, SEEK_SET);
    444 			if(res == (off_t)-1)
    445 				return res;
    446 			/* ??? perhaps fallback to close / open */
    447 
    448 			inflateEnd(&(s->stream));
    449 
    450 			sav_inbuf = s->inbuf; /* don't allocate again */
    451 			(void)memset(s, 0, sizeof(struct sd));
    452 			/* this resets total_out to 0! */
    453 
    454 			inflateInit2(&(s->stream), -15);
    455 			s->stream.next_in = s->inbuf = sav_inbuf;
    456 
    457 			s->fd = fd;
    458 			check_header(s); /* skip the .gz header */
    459 		}
    460 
    461 		/* to seek forwards, throw away data */
    462 		if (offset > s->stream.total_out) {
    463 			off_t toskip = offset - s->stream.total_out;
    464 
    465 			while (toskip > 0) {
    466 #define DUMMYBUFSIZE 256
    467 				char dummybuf[DUMMYBUFSIZE];
    468 				off_t len = toskip;
    469 
    470 				if (len > DUMMYBUFSIZE)
    471 					len = DUMMYBUFSIZE;
    472 				if (read(fd, dummybuf, len) != len) {
    473 					errno = EOFFSET;
    474 					return (off_t)-1;
    475 				}
    476 				toskip -= len;
    477 			}
    478 		}
    479 #ifdef DEBUG
    480 		if (offset != s->stream.total_out)
    481 			panic("lseek compressed");
    482 #endif
    483 		return offset;
    484 	case SEEK_END:
    485 		errno = EOFFSET;
    486 		break;
    487 	default:
    488 		errno = EINVAL;
    489 		break;
    490 	}
    491 
    492 	return (off_t)-1;
    493 }
    494