ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/liblzf/lzf.c
(Generate patch)

Comparing liblzf/lzf.c (file contents):
Revision 1.2 by root, Sun Nov 17 11:39:26 2002 UTC vs.
Revision 1.12 by root, Fri Nov 2 12:39:20 2007 UTC

1/* 1/*
2 * Copyright (c) 2000-2002 Marc Alexander Lehmann <pcg@goof.com> 2 * Copyright (c) 2006 Stefan Traby <stefan@hello-penguin.com>
3 * 3 *
4 * Redistribution and use in source and binary forms, with or without modifica- 4 * Redistribution and use in source and binary forms, with or without modifica-
5 * tion, are permitted provided that the following conditions are met: 5 * tion, are permitted provided that the following conditions are met:
6 * 6 *
7 * 1. Redistributions of source code must retain the above copyright notice, 7 * 1. Redistributions of source code must retain the above copyright notice,
… …
9 * 9 *
10 * 2. Redistributions in binary form must reproduce the above copyright 10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the 11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution. 12 * documentation and/or other materials provided with the distribution.
13 * 13 *
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER- 15 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
19 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 16 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
20 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE- 17 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
21 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 18 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 20 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH- 21 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
25 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 22 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
26 * OF THE POSSIBILITY OF SUCH DAMAGE. 23 * OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 * Alternatively, the contents of this file may be used under the terms of
26 * the GNU General Public License version 2 (the "GPL"), in which case the
27 * provisions of the GPL are applicable instead of the above. If you wish to
28 * allow the use of your version of this file only under the terms of the
29 * GPL and not to allow others to use your version of this file under the
30 * BSD license, indicate your decision by deleting the provisions above and
31 * replace them with the notice and other provisions required by the GPL. If
32 * you do not delete the provisions above, a recipient may use your version
33 * of this file under either the BSD or the GPL License.
27 */ 34 */
28 35
29#include "config.h" 36#include "config.h"
30
31#include <stdio.h> 37#include <stdio.h>
38#include <string.h>
32#include <stdlib.h> 39#include <stdlib.h>
33#include <assert.h>
34
35#include <unistd.h> 40#include <unistd.h>
41#include <sys/types.h>
42#include <sys/stat.h>
43#include <fcntl.h>
36#include <getopt.h> 44#include <errno.h>
37 45#include <limits.h>
38#include "lzf.h" 46#include "lzf.h"
39 47
48#ifdef HAVE_GETOPT_H
49# include <getopt.h>
50#endif
51
52#define BLOCKSIZE (1024 * 64 - 1)
53#define MAX_BLOCKSIZE BLOCKSIZE
54
55typedef unsigned char u8;
56
57static off_t nr_read, nr_written;
58
59static const char *imagename;
60static enum { compress, uncompress, lzcat } mode = compress;
61static int verbose = 0;
62static int force = 0;
63static long blocksize = BLOCKSIZE;
64
65#ifdef HAVE_GETOPT_LONG
66
67 struct option longopts[] = {
68 {"compress", 0, 0, 'c'},
69 {"decompress", 0, 0, 'd'},
70 {"uncompress", 0, 0, 'd'},
71 {"force", 0, 0, 'f'},
72 {"help", 0, 0, 'h'},
73 {"verbose", 0, 0, 'v'},
74 {"blocksize", 1, 0, 'b'},
75 {0, 0, 0, 0}
76 };
77
78 static const char *opt =
79 "-c --compress compress\n"
80 "-d --decompress decompress\n"
81 "-f --force force overwrite of output file\n"
82 "-h --help give this help\n" "-v --verbose verbose mode\n" "-b # --blocksize # set blocksize\n" "\n";
83
84#else
85
86 static const char *opt =
87 "-c compress\n"
88 "-d decompress\n"
89 "-f force overwrite of output file\n"
90 "-h give this help\n"
91 "-v verbose mode\n"
92 "-b # set blocksize\n"
93 "\n";
94
95#endif
96
40static void 97static void
41usage (int ec) 98usage (int rc)
42{ 99{
43 fprintf (stderr, "\n" 100 fprintf (stderr, "\n"
44 "lzf, a very leightweight compression/decompression filter\n" 101 "lzf, a very lightweight compression/decompression utility written by Stefan Traby.\n"
45 "written by Marc Lehmann <pcg@goof.com> You can find more info at\n" 102 "uses liblzf written by Marc Lehmann <schmorp@schmorp.de> You can find more info at\n"
46 "http://liblzv.plan9.de/\n" 103 "http://liblzf.plan9.de/\n"
47 "\n" 104 "\n"
48 "USAGE: lzf -c [-b blocksize] | -d\n" 105 "usage: lzf [-dufhvb] [file ...]\n"
49 " -c compress\n" 106 " unlzf [file ...]\n"
50 " -d decompress\n" 107 " lzcat [file ...]\n"
51 " -b specify the blocksize (default 64k-1)\n"
52 "\n" 108 "\n%s",
53 ); 109 opt);
54 110
55 exit (ec); 111 exit (rc);
112}
113
114static inline ssize_t
115rread (int fd, void *buf, size_t len)
116{
117 ssize_t rc = 0, offset = 0;
118 char *p = buf;
119
120 while (len && (rc = read (fd, &p[offset], len)) > 0)
121 {
122 offset += rc;
123 len -= rc;
124 }
125
126 nr_read += offset;
127
128 if (rc < 0)
129 return rc;
130
131 return offset;
132}
133
134/* returns 0 if all written else -1 */
135static inline ssize_t
136wwrite (int fd, void *buf, size_t len)
137{
138 ssize_t rc;
139 char *b = buf;
140 size_t l = len;
141
142 while (l)
143 {
144 rc = write (fd, b, l);
145 if (rc < 0)
146 {
147 fprintf (stderr, "%s: write error: ", imagename);
148 perror ("");
149 return -1;
150 }
151
152 l -= rc;
153 b += rc;
154 }
155
156 nr_written += len;
157 return 0;
56} 158}
57 159
58/* 160/*
59 * Anatomy: an lzf file consists of any number of blocks in the following format: 161 * Anatomy: an lzf file consists of any number of blocks in the following format:
60 * 162 *
163 * \x00 EOF (optional)
61 * "ZV\0" 2-byte-usize <uncompressed data> 164 * "ZV\0" 2-byte-usize <uncompressed data>
62 * "ZV\1" 2-byte-csize 2-byte-usize <compressed data> 165 * "ZV\1" 2-byte-csize 2-byte-usize <compressed data>
63 * "ZV\2" 4-byte-crc32-0xdebb20e3 (NYI) 166 * "ZV\2" 4-byte-crc32-0xdebb20e3 (NYI)
64 *
65 */ 167 */
66 168
67static void compress (unsigned int blocksize) 169
170#define TYPE0_HDR_SIZE 5
171#define TYPE1_HDR_SIZE 7
172#define MAX_HDR_SIZE 7
173#define MIN_HDR_SIZE 5
174
175static int
176compress_fd (int from, int to)
68{ 177{
69 ssize_t us; 178 ssize_t us, cs, len;
70 unsigned int cs; 179 u8 buf1[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
71 u8 buff1[64*1024]; 180 u8 buf2[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
72 u8 buff2[64*1024];
73 u8 header[3+2+2]; 181 u8 *header;
74 182
75 header[0] = 'Z'; 183 nr_read = nr_written = 0;
76 header[1] = 'V'; 184 while ((us = rread (from, &buf1[MAX_HDR_SIZE], blocksize)) > 0)
77
78 for(;;) {
79 us = fread (buff1, 1, blocksize, stdin);
80
81 if (us < blocksize)
82 { 185 {
83 if (us == 0) 186 cs = lzf_compress (&buf1[MAX_HDR_SIZE], us, &buf2[MAX_HDR_SIZE], us > 4 ? us - 4 : us);
84 break;
85 else if (!feof (stdin))
86 {
87 perror ("compress");
88 exit (1);
89 }
90 }
91
92 cs = lzf_compress (buff1, us, buff2, us - 4);
93
94 if (cs) 187 if (cs)
95 { 188 {
189 header = &buf2[MAX_HDR_SIZE - TYPE1_HDR_SIZE];
190 header[0] = 'Z';
191 header[1] = 'V';
96 header[2] = 1; 192 header[2] = 1;
97 header[3] = cs >> 8; 193 header[3] = cs >> 8;
98 header[4] = cs & 0xff; 194 header[4] = cs & 0xff;
99 header[5] = us >> 8; 195 header[5] = us >> 8;
100 header[6] = us & 0xff; 196 header[6] = us & 0xff;
101 197 len = cs + TYPE1_HDR_SIZE;
102 fwrite (header, 3+2+2, 1, stdout);
103 fwrite (buff2, cs, 1, stdout);
104 } 198 }
105 else 199 else
106 { 200 { // write uncompressed
201 header = &buf1[MAX_HDR_SIZE - TYPE0_HDR_SIZE];
202 header[0] = 'Z';
203 header[1] = 'V';
107 header[2] = 0; 204 header[2] = 0;
108 header[3] = us >> 8; 205 header[3] = us >> 8;
109 header[4] = us & 0xff; 206 header[4] = us & 0xff;
110 207 len = us + TYPE0_HDR_SIZE;
111 fwrite (header, 3+2, 1, stdout);
112 fwrite (buff1, us, 1, stdout);
113 } 208 }
114 } while (!feof (stdin));
115}
116 209
117static void decompress (void) 210 if (wwrite (to, header, len) == -1)
118{ 211 return -1;
119 ssize_t us; 212 }
120 unsigned int cs;
121 u8 buff1[64*1024];
122 u8 buff2[64*1024];
123 u8 header[3+2+2];
124 213
125 for(;;) { 214 return 0;
126 if (fread (header, 3+2, 1, stdin) != 1) 215}
216
217static int
218uncompress_fd (int from, int to)
219{
220 u8 header[MAX_HDR_SIZE];
221 u8 buf1[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
222 u8 buf2[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
223 u8 *p;
224 int l, rd;
225 ssize_t rc, cs, us, bytes, over = 0;
226
227 nr_read = nr_written = 0;
228 while (1)
229 {
230 rc = rread (from, header + over, MAX_HDR_SIZE - over);
231 if (rc < 0)
127 { 232 {
128 if (feof (stdin)) 233 fprintf (stderr, "%s: read error: ", imagename);
234 perror ("");
235 return -1;
236 }
237
238 rc += over;
239 over = 0;
240 if (!rc || header[0] == 0)
241 return 0;
242
243 if (rc < MIN_HDR_SIZE || header[0] != 'Z' || header[1] != 'V')
244 {
245 fprintf (stderr, "%s: invalid data stream - magic not found or short header\n", imagename);
246 return -1;
247 }
248
249 switch (header[2])
250 {
251 case 0:
252 cs = -1;
253 us = (header[3] << 8) | header[4];
254 p = &header[TYPE0_HDR_SIZE];
129 break; 255 break;
130 else 256 case 1:
257 if (rc < TYPE1_HDR_SIZE)
131 { 258 {
132 perror ("decompress"); 259 goto short_read;
133 exit (1);
134 } 260 }
135 }
136
137 if (header[0] != 'Z' || header[1] != 'V')
138 {
139 fprintf (stderr, "decompress: invalid stream - no magic number found\n");
140 exit (1);
141 }
142
143 cs = (header[3] << 8) | header[4]; 261 cs = (header[3] << 8) | header[4];
144
145 if (header[2] == 1)
146 {
147 if (fread (header+3+2, 2, 1, stdin) != 1)
148 {
149 perror ("decompress");
150 exit (1);
151 }
152
153 us = (header[5] << 8) | header[6]; 262 us = (header[5] << 8) | header[6];
154 263 p = &header[TYPE1_HDR_SIZE];
155 if (fread (buff1, cs, 1, stdin) != 1) 264 break;
156 { 265 default:
157 perror ("decompress"); 266 fprintf (stderr, "%s: unknown blocktype\n", imagename);
158 exit (1); 267 return -1;
159 } 268 }
160 269
270 bytes = cs == -1 ? us : cs;
271 l = &header[rc] - p;
272
273 if (l > 0)
274 memcpy (buf1, p, l);
275
276 if (l > bytes)
277 {
278 over = l - bytes;
279 memmove (header, &p[bytes], over);
280 }
281
282 p = &buf1[l];
283 rd = bytes - l;
284 if (rd > 0)
285 if ((rc = rread (from, p, rd)) != rd)
286 goto short_read;
287
288 if (cs == -1)
289 {
290 if (wwrite (to, buf1, us))
291 return -1;
292 }
293 else
294 {
161 if (lzf_decompress (buff1, cs, buff2, us) != us) 295 if (lzf_decompress (buf1, cs, buf2, us) != us)
162 { 296 {
163 fprintf (stderr, "decompress: invalid stream - data corrupted\n"); 297 fprintf (stderr, "%s: decompress: invalid stream - data corrupted\n", imagename);
164 exit (1); 298 return -1;
165 } 299 }
166 300
167 fwrite (buff2, us, 1, stdout); 301 if (wwrite (to, buf2, us))
168 } 302 return -1;
169 else if (header[2] == 0)
170 {
171 if (fread (buff2, cs, 1, stdin) != 1)
172 {
173 perror ("decompress");
174 exit (1);
175 } 303 }
176
177 fwrite (buff2, cs, 1, stdout);
178 } 304 }
179 else 305
306 return 0;
307
308short_read:
309 fprintf (stderr, "%s: short data\n", imagename);
310 return -1;
311}
312
313static int
314open_out (const char *name)
315{
316 int fd;
317 int m = O_EXCL;
318
319 if (force)
320 m = 0;
321
322 fd = open (name, O_CREAT | O_WRONLY | O_TRUNC | m, 600);
323#if defined(__MINGW32__)
324 _setmode(fd, _O_BINARY);
325#endif
326 return fd;
327}
328
329static int
330compose_name (const char *fname, char *oname)
331{
332 char *p;
333
334 if (mode == compress)
335 {
336 if (strlen (fname) > PATH_MAX - 4)
180 { 337 {
181 fprintf (stderr, "decompress: invalid stream - unknown block type\n"); 338 fprintf (stderr, "%s: %s.lzf: name too long", imagename, fname);
182 exit (1); 339 return -1;
183 } 340 }
341
342 strcpy (oname, fname);
343 strcat (oname, ".lzf");
184 } 344 }
345 else
346 {
347 if (strlen (fname) > PATH_MAX)
348 {
349 fprintf (stderr, "%s: %s: name too long\n", imagename, fname);
350 return -1;
351 }
352
353 strcpy (oname, fname);
354 p = &oname[strlen (oname)] - 4;
355 if (p < oname || strcmp (p, ".lzf"))
356 {
357 fprintf (stderr, "%s: %s: unknown suffix\n", imagename, fname);
358 return -1;
359 }
360
361 *p = 0;
362 }
363
364 return 0;
365}
366
367static int
368run_file (const char *fname)
369{
370 int fd, fd2;
371 int rc;
372 struct stat mystat;
373 char oname[PATH_MAX + 1];
374
375 if (mode != lzcat)
376 if (compose_name (fname, oname))
377 return -1;
378
379#if !defined(__MINGW32__)
380 rc = lstat (fname, &mystat);
381#else
382 rc = stat (fname, &mystat);
383#endif
384 fd = open (fname, O_RDONLY);
385#if defined(__MINGW32__)
386 _setmode(fd, _O_BINARY);
387#endif
388 if (rc || fd == -1)
389 {
390 fprintf (stderr, "%s: %s: ", imagename, fname);
391 perror ("");
392 return -1;
393 }
394
395 if (!S_ISREG (mystat.st_mode))
396 {
397 fprintf (stderr, "%s: %s: not a regular file.\n", imagename, fname);
398 close (fd);
399 return -1;
400 }
401
402 if (mode == lzcat)
403 {
404 rc = uncompress_fd (fd, 1);
405 close (fd);
406 return rc;
407 }
408
409 fd2 = open_out (oname);
410 if (fd2 == -1)
411 {
412 fprintf (stderr, "%s: %s: ", imagename, oname);
413 perror ("");
414 close (fd);
415 return -1;
416 }
417
418 if (mode == compress)
419 {
420 rc = compress_fd (fd, fd2);
421 if (!rc && verbose)
422 fprintf (stderr, "%s: %5.1f%% -- replaced with %s\n",
423 fname, nr_read == 0 ? 0 : 100.0 - nr_written / ((double) nr_read / 100.0), oname);
424 }
425 else
426 {
427 rc = uncompress_fd (fd, fd2);
428 if (!rc && verbose)
429 fprintf (stderr, "%s: %5.1f%% -- replaced with %s\n",
430 fname, nr_written == 0 ? 0 : 100.0 - nr_read / ((double) nr_written / 100.0), oname);
431 }
432
433#if !defined(__MINGW32__)
434 fchmod (fd2, mystat.st_mode);
435#else
436 chmod (oname, mystat.st_mode);
437#endif
438 close (fd);
439 close (fd2);
440
441 if (!rc)
442 unlink (fname);
443
444 return rc;
185} 445}
186 446
187int 447int
188main (int argc, char *argv[]) 448main (int argc, char *argv[])
189{ 449{
450 char *p = argv[0];
190 int c; 451 int optc;
191 unsigned int blocksize = 64*1024-1; 452 int rc = 0;
192 enum { m_compress, m_decompress } mode = m_compress;
193 453
454 errno = 0;
455 p = getenv ("LZF_BLOCKSIZE");
456 if (p)
457 {
458 blocksize = strtoul (p, 0, 0);
459 if (errno || !blocksize || blocksize > MAX_BLOCKSIZE)
460 blocksize = BLOCKSIZE;
461 }
462
463 p = strrchr (argv[0], '/');
464 imagename = p ? ++p : argv[0];
465
466 if (!strncmp (imagename, "un", 2) || !strncmp (imagename, "de", 2))
467 mode = uncompress;
468
469 if (strstr (imagename, "cat"))
470 mode = lzcat;
471
472#ifdef HAVE_GETOPT_LONG
473 while ((optc = getopt_long (argc, argv, "cdfhvb:", longopts, 0)) != -1)
474#else
194 while ((c = getopt (argc, argv, "cdb:h")) != -1) 475 while ((optc = getopt (argc, argv, "cdfhvb:")) != -1)
476#endif
477 {
195 switch (c) 478 switch (optc)
196 { 479 {
197 case 'c': 480 case 'c':
198 mode = m_compress; 481 mode = compress;
199 break; 482 break;
200
201 case 'd': 483 case 'd':
202 mode = m_decompress; 484 mode = uncompress;
203 break; 485 break;
204
205 case 'b': 486 case 'f':
206 blocksize = atol (optarg); 487 force = 1;
207 break; 488 break;
208
209 case 'h': 489 case 'h':
210 usage (0); 490 usage (0);
211 491 break;
212 case ':':
213 fprintf (stderr, "required argument missing, use -h\n");
214 exit (1);
215
216 case '?': 492 case 'v':
217 fprintf (stderr, "unknown option, use -h\n"); 493 verbose = 1;
218 exit (1); 494 break;
219 495 case 'b':
496 errno = 0;
497 blocksize = strtoul (optarg, 0, 0);
498 if (errno || !blocksize || blocksize > MAX_BLOCKSIZE)
499 blocksize = BLOCKSIZE;
500 break;
220 default: 501 default:
221 usage (1); 502 usage (1);
503 break;
222 } 504 }
505 }
223 506
507 if (optind == argc)
508 { // stdin stdout
509 if (!force)
510 {
511 if ((mode == uncompress || mode == lzcat) && isatty (0))
512 {
513 fprintf (stderr, "%s: compressed data not read from a terminal. Use -f to force decompression.\n", imagename);
514 exit (1);
515 }
516 if (mode == compress && isatty (1))
517 {
518 fprintf (stderr, "%s: compressed data not written to a terminal. Use -f to force compression.\n", imagename);
519 exit (1);
520 }
521 }
522
224 if (mode == m_compress) 523 if (mode == compress)
225 compress (blocksize); 524 rc = compress_fd (0, 1);
226 else if (mode == m_decompress)
227 decompress ();
228 else 525 else
229 abort (); 526 rc = uncompress_fd (0, 1);
230 527
231 return 0; 528 exit (rc ? 1 : 0);
529 }
530
531 while (optind < argc)
532 rc |= run_file (argv[optind++]);
533
534 exit (rc ? 1 : 0);
232} 535}
536

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines