1/*-
2 * Copyright (c) 1985, 1986, 1992, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Diomidis Spinellis and James A. Woods, derived from original
7 * work by Spencer Thomas and Joseph Orost.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
|
45/*-
46 * fcompress.c - File compression ala IEEE Computer, June 1984.
47 *
48 * Compress authors:
49 * Spencer W. Thomas (decvax!utah-cs!thomas)
50 * Jim McKie (decvax!mcvax!jim)
51 * Steve Davies (decvax!vax135!petsd!peora!srd)
52 * Ken Turkowski (decvax!decwrl!turtlevax!ken)
53 * James A. Woods (decvax!ihnp4!ames!jaw)
54 * Joe Orost (decvax!vax135!petsd!joe)
55 *
56 * Cleaned up and converted to library returning I/O streams by
57 * Diomidis Spinellis <dds@doc.ic.ac.uk>.
58 *
59 * zopen(filename, mode, bits)
60 * Returns a FILE * that can be used for read or write. The modes
61 * supported are only "r" and "w". Seeking is not allowed. On
62 * reading the file is decompressed, on writing it is compressed.
63 * The output is compatible with compress(1) with 16 bit tables.
64 * Any file produced by compress(1) can be read.
65 */
66
67#include <sys/param.h>
68#include <sys/stat.h>
69
70#include <ctype.h>
71#include <errno.h>
72#include <signal.h>
73#include <stdio.h>
74#include <stdlib.h>
75#include <string.h>
76#include <unistd.h>
77#include "zopen.h"
78
79#define BITS 16 /* Default bits. */
80#define HSIZE 69001 /* 95% occupancy */
81
82/* A code_int must be able to hold 2**BITS values of type int, and also -1. */
83typedef long code_int;
84typedef long count_int;
85
86typedef u_char char_type;
87static char_type magic_header[] =
88 {'\037', '\235'}; /* 1F 9D */
89
90#define BIT_MASK 0x1f /* Defines for third byte of header. */
91#define BLOCK_MASK 0x80
92
93/*
94 * Masks 0x40 and 0x20 are free. I think 0x20 should mean that there is
95 * a fourth header byte (for expansion).
96 */
97#define INIT_BITS 9 /* Initial number of bits/code. */
98
99#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
100
101struct s_zstate {
102 FILE *zs_fp; /* File stream for I/O */
103 char zs_mode; /* r or w */
104 enum {
105 S_START, S_MIDDLE, S_EOF
106 } zs_state; /* State of computation */
107 u_int zs_n_bits; /* Number of bits/code. */
108 u_int zs_maxbits; /* User settable max # bits/code. */
109 code_int zs_maxcode; /* Maximum code, given n_bits. */
110 code_int zs_maxmaxcode; /* Should NEVER generate this code. */
111 count_int zs_htab [HSIZE];
112 u_short zs_codetab [HSIZE];
113 code_int zs_hsize; /* For dynamic table sizing. */
114 code_int zs_free_ent; /* First unused entry. */
115 /*
116 * Block compression parameters -- after all codes are used up,
117 * and compression rate changes, start over.
118 */
119 int zs_block_compress;
120 int zs_clear_flg;
121 long zs_ratio;
122 count_int zs_checkpoint;
123 u_int zs_offset;
124 long zs_in_count; /* Length of input. */
125 long zs_bytes_out; /* Length of compressed output. */
126 long zs_out_count; /* # of codes output (for debugging). */
127 char_type zs_buf[BITS];
128 union {
129 struct {
130 long zs_fcode;
131 code_int zs_ent;
132 code_int zs_hsize_reg;
133 int zs_hshift;
134 } w; /* Write paramenters */
135 struct {
136 char_type *zs_stackp;
137 int zs_finchar;
138 code_int zs_code, zs_oldcode, zs_incode;
139 int zs_roffset, zs_size;
140 char_type zs_gbuf[BITS];
141 } r; /* Read parameters */
142 } u;
143};
144
145/* Definitions to retain old variable names */
146#define fp zs->zs_fp
147#define zmode zs->zs_mode
148#define state zs->zs_state
149#define n_bits zs->zs_n_bits
150#define maxbits zs->zs_maxbits
151#define maxcode zs->zs_maxcode
152#define maxmaxcode zs->zs_maxmaxcode
153#define htab zs->zs_htab
154#define codetab zs->zs_codetab
155#define hsize zs->zs_hsize
156#define free_ent zs->zs_free_ent
157#define block_compress zs->zs_block_compress
158#define clear_flg zs->zs_clear_flg
159#define ratio zs->zs_ratio
160#define checkpoint zs->zs_checkpoint
161#define offset zs->zs_offset
162#define in_count zs->zs_in_count
163#define bytes_out zs->zs_bytes_out
164#define out_count zs->zs_out_count
165#define buf zs->zs_buf
166#define fcode zs->u.w.zs_fcode
167#define hsize_reg zs->u.w.zs_hsize_reg
168#define ent zs->u.w.zs_ent
169#define hshift zs->u.w.zs_hshift
170#define stackp zs->u.r.zs_stackp
171#define finchar zs->u.r.zs_finchar
172#define code zs->u.r.zs_code
173#define oldcode zs->u.r.zs_oldcode
174#define incode zs->u.r.zs_incode
175#define roffset zs->u.r.zs_roffset
176#define size zs->u.r.zs_size
177#define gbuf zs->u.r.zs_gbuf
178
179/*
180 * To save much memory, we overlay the table used by compress() with those
181 * used by decompress(). The tab_prefix table is the same size and type as
182 * the codetab. The tab_suffix table needs 2**BITS characters. We get this
183 * from the beginning of htab. The output stack uses the rest of htab, and
184 * contains characters. There is plenty of room for any possible stack
185 * (stack used to be 8000 characters).
186 */
187
188#define htabof(i) htab[i]
189#define codetabof(i) codetab[i]
190
191#define tab_prefixof(i) codetabof(i)
192#define tab_suffixof(i) ((char_type *)(htab))[i]
193#define de_stack ((char_type *)&tab_suffixof(1 << BITS))
194
195#define CHECK_GAP 10000 /* Ratio check interval. */
196
197/*
198 * the next two codes should not be changed lightly, as they must not
199 * lie within the contiguous general code space.
200 */
201#define FIRST 257 /* First free entry. */
202#define CLEAR 256 /* Table clear output code. */
203
204static int cl_block __P((struct s_zstate *));
205static void cl_hash __P((struct s_zstate *, count_int));
206static code_int getcode __P((struct s_zstate *));
207static int output __P((struct s_zstate *, code_int));
208static int zclose __P((void *));
209static int zread __P((void *, char *, int));
210static int zwrite __P((void *, const char *, int));
211
212/*-
213 * Algorithm from "A Technique for High Performance Data Compression",
214 * Terry A. Welch, IEEE Computer Vol 17, No 6 (June 1984), pp 8-19.
215 *
216 * Algorithm:
217 * Modified Lempel-Ziv method (LZW). Basically finds common
218 * substrings and replaces them with a variable size code. This is
219 * deterministic, and can be done on the fly. Thus, the decompression
220 * procedure needs no input table, but tracks the way the table was built.
221 */
222
223/*-
224 * compress write
225 *
226 * Algorithm: use open addressing double hashing (no chaining) on the
227 * prefix code / next character combination. We do a variant of Knuth's
228 * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
229 * secondary probe. Here, the modular division first probe is gives way
230 * to a faster exclusive-or manipulation. Also do block compression with
231 * an adaptive reset, whereby the code table is cleared when the compression
232 * ratio decreases, but after the table fills. The variable-length output
233 * codes are re-sized at this point, and a special CLEAR code is generated
234 * for the decompressor. Late addition: construct the table according to
235 * file size for noticeable speed improvement on small files. Please direct
236 * questions about this implementation to ames!jaw.
237 */
238static int
239zwrite(cookie, wbp, num)
240 void *cookie;
241 const char *wbp;
242 int num;
243{
244 code_int i;
245 int c, disp;
246 struct s_zstate *zs;
247 const u_char *bp;
248 u_char tmp;
249 int count;
250
251 if (num == 0)
252 return (0);
253
254 zs = cookie;
255 count = num;
256 bp = wbp;
257 if (state == S_MIDDLE)
258 goto middle;
259 state = S_MIDDLE;
260
261 maxmaxcode = 1L << maxbits;
262 if (fwrite(magic_header,
263 sizeof(char), sizeof(magic_header), fp) != sizeof(magic_header))
264 return (-1);
265 tmp = (u_char)((maxbits) | block_compress);
266 if (fwrite(&tmp, sizeof(char), sizeof(tmp), fp) != sizeof(tmp))
267 return (-1);
268
269 offset = 0;
270 bytes_out = 3; /* Includes 3-byte header mojo. */
271 out_count = 0;
272 clear_flg = 0;
273 ratio = 0;
274 in_count = 1;
275 checkpoint = CHECK_GAP;
276 maxcode = MAXCODE(n_bits = INIT_BITS);
277 free_ent = ((block_compress) ? FIRST : 256);
278
279 ent = *bp++;
280 --count;
281
282 hshift = 0;
283 for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L)
284 hshift++;
285 hshift = 8 - hshift; /* Set hash code range bound. */
286
287 hsize_reg = hsize;
288 cl_hash(zs, (count_int)hsize_reg); /* Clear hash table. */
289
290middle: for (i = 0; count--;) {
291 c = *bp++;
292 in_count++;
293 fcode = (long)(((long)c << maxbits) + ent);
294 i = ((c << hshift) ^ ent); /* Xor hashing. */
295
296 if (htabof(i) == fcode) {
297 ent = codetabof(i);
298 continue;
299 } else if ((long)htabof(i) < 0) /* Empty slot. */
300 goto nomatch;
301 disp = hsize_reg - i; /* Secondary hash (after G. Knott). */
302 if (i == 0)
303 disp = 1;
304probe: if ((i -= disp) < 0)
305 i += hsize_reg;
306
307 if (htabof(i) == fcode) {
308 ent = codetabof(i);
309 continue;
310 }
311 if ((long)htabof(i) >= 0)
312 goto probe;
313nomatch: if (output(zs, (code_int) ent) == -1)
314 return (-1);
315 out_count++;
316 ent = c;
317 if (free_ent < maxmaxcode) {
318 codetabof(i) = free_ent++; /* code -> hashtable */
319 htabof(i) = fcode;
320 } else if ((count_int)in_count >=
321 checkpoint && block_compress) {
322 if (cl_block(zs) == -1)
323 return (-1);
324 }
325 }
326 return (num);
327}
328
329static int
330zclose(cookie)
331 void *cookie;
332{
333 struct s_zstate *zs;
334 int rval;
335
336 zs = cookie;
337 if (zmode == 'w') { /* Put out the final code. */
338 if (output(zs, (code_int) ent) == -1) {
339 (void)fclose(fp);
340 free(zs);
341 return (-1);
342 }
343 out_count++;
344 if (output(zs, (code_int) - 1) == -1) {
345 (void)fclose(fp);
346 free(zs);
347 return (-1);
348 }
349 }
350 rval = fclose(fp) == EOF ? -1 : 0;
351 free(zs);
352 return (rval);
353}
354
355/*-
356 * Output the given code.
357 * Inputs:
358 * code: A n_bits-bit integer. If == -1, then EOF. This assumes
359 * that n_bits =< (long)wordsize - 1.
360 * Outputs:
361 * Outputs code to the file.
362 * Assumptions:
363 * Chars are 8 bits long.
364 * Algorithm:
365 * Maintain a BITS character long buffer (so that 8 codes will
366 * fit in it exactly). Use the VAX insv instruction to insert each
367 * code in turn. When the buffer fills up empty it and start over.
368 */
369
370static char_type lmask[9] =
371 {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
372static char_type rmask[9] =
373 {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
374
375static int
376output(zs, ocode)
377 struct s_zstate *zs;
378 code_int ocode;
379{
380 int r_off;
381 u_int bits;
382 char_type *bp;
383
384 r_off = offset;
385 bits = n_bits;
386 bp = buf;
387 if (ocode >= 0) {
388 /* Get to the first byte. */
389 bp += (r_off >> 3);
390 r_off &= 7;
391 /*
392 * Since ocode is always >= 8 bits, only need to mask the first
393 * hunk on the left.
394 */
395 *bp = (*bp & rmask[r_off]) | ((ocode << r_off) & lmask[r_off]);
396 bp++;
397 bits -= (8 - r_off);
398 ocode >>= 8 - r_off;
399 /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
400 if (bits >= 8) {
401 *bp++ = ocode;
402 ocode >>= 8;
403 bits -= 8;
404 }
405 /* Last bits. */
406 if (bits)
407 *bp = ocode;
408 offset += n_bits;
409 if (offset == (n_bits << 3)) {
410 bp = buf;
411 bits = n_bits;
412 bytes_out += bits;
413 if (fwrite(bp, sizeof(char), bits, fp) != bits)
414 return (-1);
415 bp += bits;
416 bits = 0;
417 offset = 0;
418 }
419 /*
420 * If the next entry is going to be too big for the ocode size,
421 * then increase it, if possible.
422 */
423 if (free_ent > maxcode || (clear_flg > 0)) {
424 /*
425 * Write the whole buffer, because the input side won't
426 * discover the size increase until after it has read it.
427 */
428 if (offset > 0) {
429 if (fwrite(buf, 1, n_bits, fp) != n_bits)
430 return (-1);
431 bytes_out += n_bits;
432 }
433 offset = 0;
434
435 if (clear_flg) {
436 maxcode = MAXCODE(n_bits = INIT_BITS);
437 clear_flg = 0;
438 } else {
439 n_bits++;
440 if (n_bits == maxbits)
441 maxcode = maxmaxcode;
442 else
443 maxcode = MAXCODE(n_bits);
444 }
445 }
446 } else {
447 /* At EOF, write the rest of the buffer. */
448 if (offset > 0) {
449 offset = (offset + 7) / 8;
450 if (fwrite(buf, 1, offset, fp) != offset)
451 return (-1);
452 bytes_out += offset;
453 }
454 offset = 0;
455 }
456 return (0);
457}
458
459/*
460 * Decompress read. This routine adapts to the codes in the file building
461 * the "string" table on-the-fly; requiring no table to be stored in the
462 * compressed file. The tables used herein are shared with those of the
463 * compress() routine. See the definitions above.
464 */
465static int
466zread(cookie, rbp, num)
467 void *cookie;
468 char *rbp;
469 int num;
470{
471 u_int count;
472 struct s_zstate *zs;
473 u_char *bp, header[3];
474
475 if (num == 0)
476 return (0);
477
478 zs = cookie;
479 count = num;
480 bp = (u_char *)rbp;
481 switch (state) {
482 case S_START:
483 state = S_MIDDLE;
484 break;
485 case S_MIDDLE:
486 goto middle;
487 case S_EOF:
488 goto eof;
489 }
490
491 /* Check the magic number */
492 if (fread(header,
493 sizeof(char), sizeof(header), fp) != sizeof(header) ||
494 memcmp(header, magic_header, sizeof(magic_header)) != 0) {
495 errno = EFTYPE;
496 return (-1);
497 }
498 maxbits = header[2]; /* Set -b from file. */
499 block_compress = maxbits & BLOCK_MASK;
500 maxbits &= BIT_MASK;
501 maxmaxcode = 1L << maxbits;
502 if (maxbits > BITS) {
503 errno = EFTYPE;
504 return (-1);
505 }
506 /* As above, initialize the first 256 entries in the table. */
507 maxcode = MAXCODE(n_bits = INIT_BITS);
508 for (code = 255; code >= 0; code--) {
509 tab_prefixof(code) = 0;
510 tab_suffixof(code) = (char_type) code;
511 }
512 free_ent = block_compress ? FIRST : 256;
513
514 finchar = oldcode = getcode(zs);
515 if (oldcode == -1) /* EOF already? */
516 return (0); /* Get out of here */
517
518 /* First code must be 8 bits = char. */
519 *bp++ = (u_char)finchar;
520 count--;
521 stackp = de_stack;
522
523 while ((code = getcode(zs)) > -1) {
524
525 if ((code == CLEAR) && block_compress) {
526 for (code = 255; code >= 0; code--)
527 tab_prefixof(code) = 0;
528 clear_flg = 1;
529 free_ent = FIRST - 1;
530 if ((code = getcode(zs)) == -1) /* O, untimely death! */
531 break;
532 }
533 incode = code;
534
535 /* Special case for KwKwK string. */
536 if (code >= free_ent) {
537 *stackp++ = finchar;
538 code = oldcode;
539 }
540
541 /* Generate output characters in reverse order. */
542 while (code >= 256) {
543 *stackp++ = tab_suffixof(code);
544 code = tab_prefixof(code);
545 }
546 *stackp++ = finchar = tab_suffixof(code);
547
548 /* And put them out in forward order. */
549middle: do {
550 if (count-- == 0)
551 return (num);
552 *bp++ = *--stackp;
553 } while (stackp > de_stack);
554
555 /* Generate the new entry. */
556 if ((code = free_ent) < maxmaxcode) {
557 tab_prefixof(code) = (u_short) oldcode;
558 tab_suffixof(code) = finchar;
559 free_ent = code + 1;
560 }
561
562 /* Remember previous code. */
563 oldcode = incode;
564 }
565 state = S_EOF;
566eof: return (num - count);
567}
568
569/*-
570 * Read one code from the standard input. If EOF, return -1.
571 * Inputs:
572 * stdin
573 * Outputs:
574 * code or -1 is returned.
575 */
576static code_int
577getcode(zs)
578 struct s_zstate *zs;
579{
580 code_int gcode;
581 int r_off, bits;
582 char_type *bp;
583
584 bp = gbuf;
585 if (clear_flg > 0 || roffset >= size || free_ent > maxcode) {
586 /*
587 * If the next entry will be too big for the current gcode
588 * size, then we must increase the size. This implies reading
589 * a new buffer full, too.
590 */
591 if (free_ent > maxcode) {
592 n_bits++;
593 if (n_bits == maxbits) /* Won't get any bigger now. */
594 maxcode = maxmaxcode;
595 else
596 maxcode = MAXCODE(n_bits);
597 }
598 if (clear_flg > 0) {
599 maxcode = MAXCODE(n_bits = INIT_BITS);
600 clear_flg = 0;
601 }
602 size = fread(gbuf, 1, n_bits, fp);
603 if (size <= 0) /* End of file. */
604 return (-1);
605 roffset = 0;
606 /* Round size down to integral number of codes. */
607 size = (size << 3) - (n_bits - 1);
608 }
609 r_off = roffset;
610 bits = n_bits;
611
612 /* Get to the first byte. */
613 bp += (r_off >> 3);
614 r_off &= 7;
615
616 /* Get first part (low order bits). */
617 gcode = (*bp++ >> r_off);
618 bits -= (8 - r_off);
619 r_off = 8 - r_off; /* Now, roffset into gcode word. */
620
621 /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
622 if (bits >= 8) {
623 gcode |= *bp++ << r_off;
624 r_off += 8;
625 bits -= 8;
626 }
627
628 /* High order bits. */
629 gcode |= (*bp & rmask[bits]) << r_off;
630 roffset += n_bits;
631
632 return (gcode);
633}
634
635static int
636cl_block(zs) /* Table clear for block compress. */
637 struct s_zstate *zs;
638{
639 long rat;
640
641 checkpoint = in_count + CHECK_GAP;
642
643 if (in_count > 0x007fffff) { /* Shift will overflow. */
644 rat = bytes_out >> 8;
645 if (rat == 0) /* Don't divide by zero. */
646 rat = 0x7fffffff;
647 else
648 rat = in_count / rat;
649 } else
650 rat = (in_count << 8) / bytes_out; /* 8 fractional bits. */
651 if (rat > ratio)
652 ratio = rat;
653 else {
654 ratio = 0;
655 cl_hash(zs, (count_int) hsize);
656 free_ent = FIRST;
657 clear_flg = 1;
658 if (output(zs, (code_int) CLEAR) == -1)
659 return (-1);
660 }
661 return (0);
662}
663
664static void
665cl_hash(zs, cl_hsize) /* Reset code table. */
666 struct s_zstate *zs;
667 count_int cl_hsize;
668{
669 count_int *htab_p;
670 long i, m1;
671
672 m1 = -1;
673 htab_p = htab + cl_hsize;
674 i = cl_hsize - 16;
675 do { /* Might use Sys V memset(3) here. */
676 *(htab_p - 16) = m1;
677 *(htab_p - 15) = m1;
678 *(htab_p - 14) = m1;
679 *(htab_p - 13) = m1;
680 *(htab_p - 12) = m1;
681 *(htab_p - 11) = m1;
682 *(htab_p - 10) = m1;
683 *(htab_p - 9) = m1;
684 *(htab_p - 8) = m1;
685 *(htab_p - 7) = m1;
686 *(htab_p - 6) = m1;
687 *(htab_p - 5) = m1;
688 *(htab_p - 4) = m1;
689 *(htab_p - 3) = m1;
690 *(htab_p - 2) = m1;
691 *(htab_p - 1) = m1;
692 htab_p -= 16;
693 } while ((i -= 16) >= 0);
694 for (i += 16; i > 0; i--)
695 *--htab_p = m1;
696}
697
698FILE *
699zopen(fname, mode, bits)
700 const char *fname, *mode;
701 int bits;
702{
703 struct s_zstate *zs;
704
705 if ((mode[0] != 'r' && mode[0] != 'w') || mode[1] != '\0' ||
706 bits < 0 || bits > BITS) {
707 errno = EINVAL;
708 return (NULL);
709 }
710
711 if ((zs = calloc(1, sizeof(struct s_zstate))) == NULL)
712 return (NULL);
713
714 maxbits = bits ? bits : BITS; /* User settable max # bits/code. */
715 maxmaxcode = 1L << maxbits; /* Should NEVER generate this code. */
716 hsize = HSIZE; /* For dynamic table sizing. */
717 free_ent = 0; /* First unused entry. */
718 block_compress = BLOCK_MASK;
719 clear_flg = 0;
720 ratio = 0;
721 checkpoint = CHECK_GAP;
722 in_count = 1; /* Length of input. */
723 out_count = 0; /* # of codes output (for debugging). */
724 state = S_START;
725 roffset = 0;
726 size = 0;
727
728 /*
729 * Layering compress on top of stdio in order to provide buffering,
730 * and ensure that reads and write work with the data specified.
731 */
732 if ((fp = fopen(fname, mode)) == NULL) {
733 free(zs);
734 return (NULL);
735 }
736 switch (*mode) {
737 case 'r':
738 zmode = 'r';
739 return (funopen(zs, zread, NULL, NULL, zclose));
740 case 'w':
741 zmode = 'w';
742 return (funopen(zs, NULL, zwrite, NULL, zclose));
743 }
744 /* NOTREACHED */
745 return (NULL);
746}
|