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