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