1/*
2 * Copyright (c) 1998 Michael Smith.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/11/stand/libsa/gzipfs.c 344408 2019-02-21 02:43:48Z kevans $");
29
30#include "stand.h"
31
32#include <sys/stat.h>
33#include <string.h>
34#include <zlib.h>
35
36#define Z_BUFSIZE 2048	/* XXX larger? */
37
38struct z_file
39{
40    int			zf_rawfd;
41    off_t		zf_dataoffset;
42    z_stream		zf_zstream;
43    unsigned char	zf_buf[Z_BUFSIZE];
44    int			zf_endseen;
45};
46
47static int	zf_fill(struct z_file *z);
48static int	zf_open(const char *path, struct open_file *f);
49static int	zf_close(struct open_file *f);
50static int	zf_read(struct open_file *f, void *buf, size_t size, size_t *resid);
51static off_t	zf_seek(struct open_file *f, off_t offset, int where);
52static int	zf_stat(struct open_file *f, struct stat *sb);
53
54struct fs_ops gzipfs_fsops = {
55    "zip",
56    zf_open,
57    zf_close,
58    zf_read,
59    null_write,
60    zf_seek,
61    zf_stat,
62    null_readdir
63};
64
65static int
66zf_fill(struct z_file *zf)
67{
68    int		result;
69    int		req;
70
71    req = Z_BUFSIZE - zf->zf_zstream.avail_in;
72    result = 0;
73
74    /* If we need more */
75    if (req > 0) {
76	/* move old data to bottom of buffer */
77	if (req < Z_BUFSIZE)
78	    bcopy(zf->zf_buf + req, zf->zf_buf, Z_BUFSIZE - req);
79
80	/* read to fill buffer and update availibility data */
81	result = read(zf->zf_rawfd, zf->zf_buf + zf->zf_zstream.avail_in, req);
82	zf->zf_zstream.next_in = zf->zf_buf;
83	if (result >= 0)
84	    zf->zf_zstream.avail_in += result;
85    }
86    return(result);
87}
88
89/*
90 * Adapted from get_byte/check_header in libz
91 *
92 * Returns 0 if the header is OK, nonzero if not.
93 */
94static int
95get_byte(struct z_file *zf, off_t *curoffp)
96{
97    if ((zf->zf_zstream.avail_in == 0) && (zf_fill(zf) == -1))
98	return(-1);
99    zf->zf_zstream.avail_in--;
100    ++*curoffp;
101    return(*(zf->zf_zstream.next_in)++);
102}
103
104static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
105
106/* gzip flag byte */
107#define ASCII_FLAG	0x01 /* bit 0 set: file probably ascii text */
108#define HEAD_CRC	0x02 /* bit 1 set: header CRC present */
109#define EXTRA_FIELD	0x04 /* bit 2 set: extra field present */
110#define ORIG_NAME	0x08 /* bit 3 set: original file name present */
111#define COMMENT		0x10 /* bit 4 set: file comment present */
112#define RESERVED	0xE0 /* bits 5..7: reserved */
113
114static int
115check_header(struct z_file *zf)
116{
117    int		method; /* method byte */
118    int		flags;  /* flags byte */
119    uInt	len;
120    int		c;
121
122    zf->zf_dataoffset = 0;
123    /* Check the gzip magic header */
124    for (len = 0; len < 2; len++) {
125	c = get_byte(zf, &zf->zf_dataoffset);
126	if (c != gz_magic[len]) {
127	    return(1);
128	}
129    }
130    method = get_byte(zf, &zf->zf_dataoffset);
131    flags = get_byte(zf, &zf->zf_dataoffset);
132    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
133	return(1);
134    }
135
136    /* Discard time, xflags and OS code: */
137    for (len = 0; len < 6; len++) (void)get_byte(zf, &zf->zf_dataoffset);
138
139    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
140	len  =  (uInt)get_byte(zf, &zf->zf_dataoffset);
141	len += ((uInt)get_byte(zf, &zf->zf_dataoffset))<<8;
142	/* len is garbage if EOF but the loop below will quit anyway */
143	while (len-- != 0 && get_byte(zf, &zf->zf_dataoffset) != -1) ;
144    }
145    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
146	while ((c = get_byte(zf, &zf->zf_dataoffset)) != 0 && c != -1) ;
147    }
148    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
149	while ((c = get_byte(zf, &zf->zf_dataoffset)) != 0 && c != -1) ;
150    }
151    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
152	for (len = 0; len < 2; len++) c = get_byte(zf, &zf->zf_dataoffset);
153    }
154    /* if there's data left, we're in business */
155    return((c == -1) ? 1 : 0);
156}
157
158static int
159zf_open(const char *fname, struct open_file *f)
160{
161    static char		*zfname;
162    int			rawfd;
163    struct z_file	*zf;
164    char		*cp;
165    int			error;
166    struct stat		sb;
167
168    /* Have to be in "just read it" mode */
169    if (f->f_flags != F_READ)
170	return(EPERM);
171
172    /* If the name already ends in .gz or .bz2, ignore it */
173    if ((cp = strrchr(fname, '.')) && (!strcmp(cp, ".gz")
174	    || !strcmp(cp, ".bz2") || !strcmp(cp, ".split")))
175	return(ENOENT);
176
177    /* Construct new name */
178    zfname = malloc(strlen(fname) + 4);
179    if (zfname == NULL)
180        return(ENOMEM);
181    sprintf(zfname, "%s.gz", fname);
182
183    /* Try to open the compressed datafile */
184    rawfd = open(zfname, O_RDONLY);
185    free(zfname);
186    if (rawfd == -1)
187	return(ENOENT);
188
189    if (fstat(rawfd, &sb) < 0) {
190	printf("zf_open: stat failed\n");
191	close(rawfd);
192	return(ENOENT);
193    }
194    if (!S_ISREG(sb.st_mode)) {
195	printf("zf_open: not a file\n");
196	close(rawfd);
197	return(EISDIR);			/* best guess */
198    }
199
200    /* Allocate a z_file structure, populate it */
201    zf = malloc(sizeof(struct z_file));
202    if (zf == NULL)
203        return(ENOMEM);
204    bzero(zf, sizeof(struct z_file));
205    zf->zf_rawfd = rawfd;
206
207    /* Verify that the file is gzipped */
208    if (check_header(zf)) {
209	close(zf->zf_rawfd);
210	free(zf);
211	return(EFTYPE);
212    }
213
214    /* Initialise the inflation engine */
215    if ((error = inflateInit2(&(zf->zf_zstream), -15)) != Z_OK) {
216	printf("zf_open: inflateInit returned %d : %s\n", error, zf->zf_zstream.msg);
217	close(zf->zf_rawfd);
218	free(zf);
219	return(EIO);
220    }
221
222    /* Looks OK, we'll take it */
223    f->f_fsdata = zf;
224    return(0);
225}
226
227static int
228zf_close(struct open_file *f)
229{
230    struct z_file	*zf = (struct z_file *)f->f_fsdata;
231
232    inflateEnd(&(zf->zf_zstream));
233    close(zf->zf_rawfd);
234    free(zf);
235    return(0);
236}
237
238static int
239zf_read(struct open_file *f, void *buf, size_t size, size_t *resid)
240{
241    struct z_file	*zf = (struct z_file *)f->f_fsdata;
242    int			error;
243
244    zf->zf_zstream.next_out = buf;			/* where and how much */
245    zf->zf_zstream.avail_out = size;
246
247    while (zf->zf_zstream.avail_out && zf->zf_endseen == 0) {
248	if ((zf->zf_zstream.avail_in == 0) && (zf_fill(zf) == -1)) {
249	    printf("zf_read: fill error\n");
250	    return(EIO);
251	}
252	if (zf->zf_zstream.avail_in == 0) {		/* oops, unexpected EOF */
253	    printf("zf_read: unexpected EOF\n");
254	    if (zf->zf_zstream.avail_out == size)
255		return(EIO);
256	    break;
257	}
258
259	error = inflate(&zf->zf_zstream, Z_SYNC_FLUSH);	/* decompression pass */
260	if (error == Z_STREAM_END) {			/* EOF, all done */
261	    zf->zf_endseen = 1;
262	    break;
263	}
264	if (error != Z_OK) {				/* argh, decompression error */
265	    printf("inflate: %s\n", zf->zf_zstream.msg);
266	    return(EIO);
267	}
268    }
269    if (resid != NULL)
270	*resid = zf->zf_zstream.avail_out;
271    return(0);
272}
273
274static int
275zf_rewind(struct open_file *f)
276{
277    struct z_file	*zf = (struct z_file *)f->f_fsdata;
278
279    if (lseek(zf->zf_rawfd, zf->zf_dataoffset, SEEK_SET) == -1)
280	return(-1);
281    zf->zf_zstream.avail_in = 0;
282    zf->zf_zstream.next_in = NULL;
283    zf->zf_endseen = 0;
284    (void)inflateReset(&zf->zf_zstream);
285
286    return(0);
287}
288
289static off_t
290zf_seek(struct open_file *f, off_t offset, int where)
291{
292    struct z_file	*zf = (struct z_file *)f->f_fsdata;
293    off_t		target;
294    char		discard[16];
295
296    switch (where) {
297    case SEEK_SET:
298	target = offset;
299	break;
300    case SEEK_CUR:
301	target = offset + zf->zf_zstream.total_out;
302	break;
303    default:
304	errno = EINVAL;
305	return(-1);
306    }
307
308    /* rewind if required */
309    if (target < zf->zf_zstream.total_out && zf_rewind(f) != 0)
310	return(-1);
311
312    /* skip forwards if required */
313    while (target > zf->zf_zstream.total_out) {
314	errno = zf_read(f, discard, min(sizeof(discard),
315	    target - zf->zf_zstream.total_out), NULL);
316	if (errno)
317	    return(-1);
318    }
319    /* This is where we are (be honest if we overshot) */
320    return(zf->zf_zstream.total_out);
321}
322
323
324static int
325zf_stat(struct open_file *f, struct stat *sb)
326{
327    struct z_file	*zf = (struct z_file *)f->f_fsdata;
328    int			result;
329
330    /* stat as normal, but indicate that size is unknown */
331    if ((result = fstat(zf->zf_rawfd, sb)) == 0)
332	sb->st_size = -1;
333    return(result);
334}
335
336
337
338