Boot loader fixes - fix recursive malloc()/free() errors, NULL freed fields
[dragonfly.git] / lib / libstand / bzipfs.c
1 /* 
2  * Copyright (c) 1998 Michael Smith.
3  * Copyright (c) 2000 Maxim Sobolev
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  * $FreeBSD: src/lib/libstand/bzipfs.c,v 1.2.2.3 2002/04/08 13:50:09 sobomax Exp $
28  * $DragonFly: src/lib/libstand/bzipfs.c,v 1.4 2007/05/13 18:33:56 swildner Exp $
29  *
30  */
31
32 #include "stand.h"
33
34 #include <sys/stat.h>
35 #include <string.h>
36 #include <bzlib.h>
37
38 #define BZ_BUFSIZE 2048 /* XXX larger? */
39
40 struct bz_file
41 {
42     int                 bzf_rawfd;
43     bz_stream           bzf_bzstream;
44     char                bzf_buf[BZ_BUFSIZE];
45 };
46
47 static int      bzf_fill(struct bz_file *z);
48 static int      bzf_open(const char *path, struct open_file *f);
49 static int      bzf_close(struct open_file *f);
50 static int      bzf_read(struct open_file *f, void *buf, size_t size, size_t *resid);
51 static off_t    bzf_seek(struct open_file *f, off_t offset, int where);
52 static int      bzf_stat(struct open_file *f, struct stat *sb);
53
54 struct fs_ops bzipfs_fsops = {
55     "bzip",
56     bzf_open, 
57     bzf_close, 
58     bzf_read,
59     null_write,
60     bzf_seek,
61     bzf_stat,
62     null_readdir
63 };
64
65 #if 0
66 void *
67 calloc(int items, size_t size)
68 {
69     return(malloc(items * size));
70 }
71 #endif
72
73 static int
74 bzf_fill(struct bz_file *bzf)
75 {
76     int         result;
77     int         req;
78     
79     req = BZ_BUFSIZE - bzf->bzf_bzstream.avail_in;
80     result = 0;
81     
82     /* If we need more */
83     if (req > 0) {
84         /* move old data to bottom of buffer */
85         if (req < BZ_BUFSIZE)
86             bcopy(bzf->bzf_buf + req, bzf->bzf_buf, BZ_BUFSIZE - req);
87         
88         /* read to fill buffer and update availibility data */
89         result = read(bzf->bzf_rawfd, bzf->bzf_buf + bzf->bzf_bzstream.avail_in, req);
90         bzf->bzf_bzstream.next_in = bzf->bzf_buf;
91         if (result >= 0)
92             bzf->bzf_bzstream.avail_in += result;
93     }
94     return(result);
95 }
96
97 /*
98  * Adapted from get_byte/check_header in libz
99  *
100  * Returns 0 if the header is OK, nonzero if not.
101  */
102 static int
103 get_byte(struct bz_file *bzf)
104 {
105     if ((bzf->bzf_bzstream.avail_in == 0) && (bzf_fill(bzf) == -1))
106         return(-1);
107     bzf->bzf_bzstream.avail_in--;
108     return(*(bzf->bzf_bzstream.next_in)++);
109 }
110
111 static int bz_magic[3] = {'B', 'Z', 'h'}; /* bzip2 magic header */
112
113 static int
114 check_header(struct bz_file *bzf)
115 {
116     unsigned int len;
117     int          c;
118
119     /* Check the bzip2 magic header */
120     for (len = 0; len < 3; len++) {
121         c = get_byte(bzf);
122         if (c != bz_magic[len]) {
123             return(1);
124         }
125     }
126     /* Check that the block size is valid */
127     c = get_byte(bzf);
128     if (c < '1' || c > '9')
129         return(1);
130
131     /* Put back bytes that we've took from the input stream */
132     bzf->bzf_bzstream.next_in -= 4;
133     bzf->bzf_bzstream.avail_in += 4;
134
135     return(0);
136 }
137         
138 static int
139 bzf_open(const char *fname, struct open_file *f)
140 {
141     static char         *bzfname;
142     int                 rawfd;
143     struct bz_file      *bzf;
144     char                *cp;
145     int                 error;
146     struct stat         sb;
147
148     /* Have to be in "just read it" mode */
149     if (f->f_flags != F_READ)
150         return(EPERM);
151
152     /* If the name already ends in .gz or .bz2, ignore it */
153     if ((cp = strrchr(fname, '.')) && (!strcmp(cp, ".gz")
154             || !strcmp(cp, ".bz2") || !strcmp(cp, ".split")))
155         return(ENOENT);
156
157     /* Construct new name */
158     bzfname = malloc(strlen(fname) + 5);
159     sprintf(bzfname, "%s.bz2", fname);
160
161     /* Try to open the compressed datafile */
162     rawfd = open(bzfname, O_RDONLY);
163     free(bzfname);
164     if (rawfd == -1)
165         return(ENOENT);
166
167     if (fstat(rawfd, &sb) < 0) {
168         printf("bzf_open: stat failed\n");
169         close(rawfd);
170         return(ENOENT);
171     }
172     if (!S_ISREG(sb.st_mode)) {
173         printf("bzf_open: not a file\n");
174         close(rawfd);
175         return(EISDIR);                 /* best guess */
176     }
177
178     /* Allocate a bz_file structure, populate it */
179     bzf = malloc(sizeof(struct bz_file));
180     bzero(bzf, sizeof(struct bz_file));
181     bzf->bzf_rawfd = rawfd;
182
183     /* Verify that the file is bzipped (XXX why do this afterwards?) */
184     if (check_header(bzf)) {
185         close(bzf->bzf_rawfd);
186         BZ2_bzDecompressEnd(&(bzf->bzf_bzstream));
187         free(bzf);
188         return(EFTYPE);
189     }
190
191     /* Initialise the inflation engine */
192     if ((error = BZ2_bzDecompressInit(&(bzf->bzf_bzstream), 0, 1)) != BZ_OK) {
193         printf("bzf_open: BZ2_bzDecompressInit returned %d\n", error);
194         close(bzf->bzf_rawfd);
195         free(bzf);
196         return(EIO);
197     }
198
199     /* Looks OK, we'll take it */
200     f->f_fsdata = bzf;
201     return(0);
202 }
203
204 static int
205 bzf_close(struct open_file *f)
206 {
207     struct bz_file      *bzf = (struct bz_file *)f->f_fsdata;
208     
209     f->f_fsdata = NULL;
210     if (bzf) {
211         BZ2_bzDecompressEnd(&(bzf->bzf_bzstream));
212         close(bzf->bzf_rawfd);
213         free(bzf);
214     }
215     return(0);
216 }
217  
218 static int 
219 bzf_read(struct open_file *f, void *buf, size_t size, size_t *resid)
220 {
221     struct bz_file      *bzf = (struct bz_file *)f->f_fsdata;
222     int                 error;
223
224     bzf->bzf_bzstream.next_out = buf;                   /* where and how much */
225     bzf->bzf_bzstream.avail_out = size;
226
227     while (bzf->bzf_bzstream.avail_out) {
228         if ((bzf->bzf_bzstream.avail_in == 0) && (bzf_fill(bzf) == -1)) {
229             printf("bzf_read: fill error\n");
230             return(-1);
231         }
232         if (bzf->bzf_bzstream.avail_in == 0) {          /* oops, unexpected EOF */
233             printf("bzf_read: unexpected EOF\n");
234             break;
235         }
236
237         error = BZ2_bzDecompress(&bzf->bzf_bzstream);   /* decompression pass */
238         if (error == BZ_STREAM_END) {                   /* EOF, all done */
239             break;
240         }
241         if (error != BZ_OK) {                           /* argh, decompression error */
242             printf("bzf_read: BZ2_bzDecompress returned %d\n", error);
243             errno = EIO;
244             return(-1);
245         }
246     }
247     if (resid != NULL)
248         *resid = bzf->bzf_bzstream.avail_out;
249     return(0);
250 }
251
252 static off_t
253 bzf_seek(struct open_file *f, off_t offset, int where)
254 {
255     struct bz_file      *bzf = (struct bz_file *)f->f_fsdata;
256     off_t               target;
257     char                discard[16];
258     
259     switch (where) {
260     case SEEK_SET:
261         target = offset;
262         break;
263     case SEEK_CUR:
264         target = offset + bzf->bzf_bzstream.total_out_lo32;
265         break;
266     default:
267         target = -1;
268     }
269
270     /* Can we get there from here? */
271     if (target < bzf->bzf_bzstream.total_out_lo32) {
272         errno = EOFFSET;
273         return -1;
274     } 
275
276     /* skip forwards if required */
277     while (target > bzf->bzf_bzstream.total_out_lo32) {
278         if (bzf_read(f, discard, min(sizeof(discard), target - bzf->bzf_bzstream.total_out_lo32), NULL) == -1)
279             return(-1);
280     }
281     /* This is where we are (be honest if we overshot) */
282     return (bzf->bzf_bzstream.total_out_lo32);
283 }
284
285 static int
286 bzf_stat(struct open_file *f, struct stat *sb)
287 {
288     struct bz_file      *bzf = (struct bz_file *)f->f_fsdata;
289     int                 result;
290
291     /* stat as normal, but indicate that size is unknown */
292     if ((result = fstat(bzf->bzf_rawfd, sb)) == 0)
293         sb->st_size = -1;
294     return(result);
295 }
296
297 void
298 bz_internal_error(int errorcode)
299 {
300     panic("bzipfs: critical error %d in bzip2 library occurred\n", errorcode);
301 }