1 /* minigzip.c -- simulate gzip using the zlib compression library
2 * Copyright (C) 1995-2006, 2010, 2011 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6 /*
7 * minigzip is a minimal implementation of the gzip utility. This is
8 * only an example of using zlib and isn't meant to replace the
9 * full-featured gzip. No attempt is made to deal with file systems
10 * limiting names to 14 or 8+3 characters, etc... Error checking is
11 * very limited. So use minigzip only for testing; use gzip for the
12 * real thing. On MSDOS, use only on file names without extension
13 * or in pipe mode.
14 */
15
16 /* @(#) $Id$ */
17
18 #include "zlib.h"
19 #include <stdio.h>
20
21 #ifdef STDC
22 # include <string.h>
23 # include <stdlib.h>
24 #endif
25
26 #ifdef USE_MMAP
27 # include <sys/types.h>
28 # include <sys/mman.h>
29 # include <sys/stat.h>
30 #endif
31
32 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
33 # include <fcntl.h>
34 # include <io.h>
35 # ifdef UNDER_CE
36 # include <stdlib.h>
37 # endif
38 # define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
39 #else
40 # define SET_BINARY_MODE(file)
41 #endif
42
43 #ifdef _MSC_VER
44 # define snprintf _snprintf
45 #endif
46
47 #ifdef VMS
48 # define unlink delete
49 # define GZ_SUFFIX "-gz"
50 #endif
51 #ifdef RISCOS
52 # define unlink remove
53 # define GZ_SUFFIX "-gz"
54 # define fileno(file) file->__file
55 #endif
56 #if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
57 # include <unix.h> /* for fileno */
58 #endif
59
60 #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE)
61 #ifndef WIN32 /* unlink already in stdio.h for WIN32 */
62 extern int unlink OF((const char *));
63 #endif
64 #endif
65
66 #if defined(UNDER_CE)
67 # include <windows.h>
68 # define perror(s) pwinerror(s)
69
70 /* Map the Windows error number in ERROR to a locale-dependent error
71 message string and return a pointer to it. Typically, the values
72 for ERROR come from GetLastError.
73
74 The string pointed to shall not be modified by the application,
75 but may be overwritten by a subsequent call to strwinerror
76
77 The strwinerror function does not change the current setting
78 of GetLastError. */
79
80 static char *strwinerror (error)
81 DWORD error;
82 {
83 static char buf[1024];
84
85 wchar_t *msgbuf;
86 DWORD lasterr = GetLastError();
87 DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
88 | FORMAT_MESSAGE_ALLOCATE_BUFFER,
89 NULL,
90 error,
91 0, /* Default language */
92 (LPVOID)&msgbuf,
93 0,
94 NULL);
95 if (chars != 0) {
96 /* If there is an \r\n appended, zap it. */
97 if (chars >= 2
98 && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
99 chars -= 2;
100 msgbuf[chars] = 0;
101 }
102
103 if (chars > sizeof (buf) - 1) {
104 chars = sizeof (buf) - 1;
105 msgbuf[chars] = 0;
106 }
107
108 wcstombs(buf, msgbuf, chars + 1);
109 LocalFree(msgbuf);
110 }
111 else {
112 sprintf(buf, "unknown win32 error (%ld)", error);
113 }
114
115 SetLastError(lasterr);
116 return buf;
117 }
118
119 static void pwinerror (s)
120 const char *s;
121 {
122 if (s && *s)
123 fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ()));
124 else
125 fprintf(stderr, "%s\n", strwinerror(GetLastError ()));
126 }
127
128 #endif /* UNDER_CE */
129
130 #ifndef GZ_SUFFIX
131 # define GZ_SUFFIX ".gz"
132 #endif
133 #define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
134
135 #define BUFLEN 16384
136 #define MAX_NAME_LEN 1024
137
138 #ifdef MAXSEG_64K
139 # define local static
140 /* Needed for systems with limitation on stack size. */
141 #else
142 # define local
143 #endif
144
145 #ifdef Z_SOLO
146 /* for Z_SOLO, create simplified gz* functions using deflate and inflate */
147
148 #if defined(Z_HAVE_UNISTD_H) || defined(Z_LARGE)
149 # include <unistd.h> /* for unlink() */
150 #endif
151
152 void *myalloc OF((void *, unsigned, unsigned));
153 void myfree OF((void *, void *));
154
155 void *myalloc(q, n, m)
156 void *q;
157 unsigned n, m;
158 {
159 q = Z_NULL;
160 return calloc(n, m);
161 }
162
163 void myfree(q, p)
164 void *q, *p;
165 {
166 q = Z_NULL;
167 free(p);
168 }
169
170 typedef struct gzFile_s {
171 FILE *file;
172 int write;
173 int err;
174 char *msg;
175 z_stream strm;
176 } *gzFile;
177
178 gzFile gzopen OF((const char *, const char *));
179 gzFile gzdopen OF((int, const char *));
180 gzFile gz_open OF((const char *, int, const char *));
181
182 gzFile gzopen(path, mode)
183 const char *path;
184 const char *mode;
185 {
186 return gz_open(path, -1, mode);
187 }
188
189 gzFile gzdopen(fd, mode)
190 int fd;
191 const char *mode;
192 {
193 return gz_open(NULL, fd, mode);
194 }
195
196 gzFile gz_open(path, fd, mode)
197 const char *path;
198 int fd;
199 const char *mode;
200 {
201 gzFile gz;
202 int ret;
203
204 gz = malloc(sizeof(struct gzFile_s));
205 if (gz == NULL)
206 return NULL;
207 gz->write = strchr(mode, 'w') != NULL;
208 gz->strm.zalloc = myalloc;
209 gz->strm.zfree = myfree;
210 gz->strm.opaque = Z_NULL;
211 if (gz->write)
212 ret = deflateInit2(&(gz->strm), -1, 8, 15 + 16, 8, 0);
213 else {
214 gz->strm.next_in = 0;
215 gz->strm.avail_in = Z_NULL;
216 ret = inflateInit2(&(gz->strm), 15 + 16);
217 }
218 if (ret != Z_OK) {
219 free(gz);
220 return NULL;
221 }
222 gz->file = path == NULL ? fdopen(fd, gz->write ? "wb" : "rb") :
223 fopen(path, gz->write ? "wb" : "rb");
224 if (gz->file == NULL) {
225 gz->write ? deflateEnd(&(gz->strm)) : inflateEnd(&(gz->strm));
226 free(gz);
227 return NULL;
228 }
229 gz->err = 0;
230 gz->msg = "";
231 return gz;
232 }
233
234 int gzwrite OF((gzFile, const void *, unsigned));
235
236 int gzwrite(gz, buf, len)
237 gzFile gz;
238 const void *buf;
239 unsigned len;
240 {
241 z_stream *strm;
242 unsigned char out[BUFLEN];
243
244 if (gz == NULL || !gz->write)
245 return 0;
246 strm = &(gz->strm);
247 strm->next_in = (void *)buf;
248 strm->avail_in = len;
249 do {
250 strm->next_out = out;
251 strm->avail_out = BUFLEN;
252 (void)deflate(strm, Z_NO_FLUSH);
253 fwrite(out, 1, BUFLEN - strm->avail_out, gz->file);
254 } while (strm->avail_out == 0);
255 return len;
256 }
257
258 int gzread OF((gzFile, void *, unsigned));
259
260 int gzread(gz, buf, len)
261 gzFile gz;
262 void *buf;
263 unsigned len;
264 {
265 int ret;
266 unsigned got;
267 unsigned char in[1];
268 z_stream *strm;
269
270 if (gz == NULL || gz->write)
271 return 0;
272 if (gz->err)
273 return 0;
274 strm = &(gz->strm);
275 strm->next_out = (void *)buf;
276 strm->avail_out = len;
277 do {
278 got = fread(in, 1, 1, gz->file);
279 if (got == 0)
280 break;
281 strm->next_in = in;
282 strm->avail_in = 1;
283 ret = inflate(strm, Z_NO_FLUSH);
284 if (ret == Z_DATA_ERROR) {
285 gz->err = Z_DATA_ERROR;
286 gz->msg = strm->msg;
287 return 0;
288 }
289 if (ret == Z_STREAM_END)
290 inflateReset(strm);
291 } while (strm->avail_out);
292 return len - strm->avail_out;
293 }
294
295 int gzclose OF((gzFile));
296
297 int gzclose(gz)
298 gzFile gz;
299 {
300 z_stream *strm;
301 unsigned char out[BUFLEN];
302
303 if (gz == NULL)
304 return Z_STREAM_ERROR;
305 strm = &(gz->strm);
306 if (gz->write) {
307 strm->next_in = Z_NULL;
308 strm->avail_in = 0;
309 do {
310 strm->next_out = out;
311 strm->avail_out = BUFLEN;
312 (void)deflate(strm, Z_FINISH);
313 fwrite(out, 1, BUFLEN - strm->avail_out, gz->file);
314 } while (strm->avail_out == 0);
315 deflateEnd(strm);
316 }
317 else
318 inflateEnd(strm);
319 fclose(gz->file);
320 free(gz);
321 return Z_OK;
322 }
323
324 const char *gzerror OF((gzFile, int *));
325
326 const char *gzerror(gz, err)
327 gzFile gz;
328 int *err;
329 {
330 *err = gz->err;
331 return gz->msg;
332 }
333
334 #endif
335
336 char *prog;
337
338 void error OF((const char *msg));
339 void gz_compress OF((FILE *in, gzFile out));
340 #ifdef USE_MMAP
341 int gz_compress_mmap OF((FILE *in, gzFile out));
342 #endif
343 void gz_uncompress OF((gzFile in, FILE *out));
344 void file_compress OF((char *file, char *mode));
345 void file_uncompress OF((char *file));
346 int main OF((int argc, char *argv[]));
347
348 /* ===========================================================================
349 * Display error message and exit
350 */
351 void error(msg)
352 const char *msg;
353 {
354 fprintf(stderr, "%s: %s\n", prog, msg);
355 exit(1);
356 }
357
358 /* ===========================================================================
359 * Compress input to output then close both files.
360 */
361
362 void gz_compress(in, out)
363 FILE *in;
364 gzFile out;
365 {
366 local char buf[BUFLEN];
367 int len;
368 int err;
369
370 #ifdef USE_MMAP
371 /* Try first compressing with mmap. If mmap fails (minigzip used in a
372 * pipe), use the normal fread loop.
373 */
374 if (gz_compress_mmap(in, out) == Z_OK) return;
375 #endif
376 for (;;) {
377 len = (int)fread(buf, 1, sizeof(buf), in);
378 if (ferror(in)) {
379 perror("fread");
380 exit(1);
381 }
382 if (len == 0) break;
383
384 if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
385 }
386 fclose(in);
387 if (gzclose(out) != Z_OK) error("failed gzclose");
388 }
389
390 #ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
391
392 /* Try compressing the input file at once using mmap. Return Z_OK if
393 * if success, Z_ERRNO otherwise.
394 */
395 int gz_compress_mmap(in, out)
396 FILE *in;
397 gzFile out;
398 {
399 int len;
400 int err;
401 int ifd = fileno(in);
402 caddr_t buf; /* mmap'ed buffer for the entire input file */
403 off_t buf_len; /* length of the input file */
404 struct stat sb;
405
406 /* Determine the size of the file, needed for mmap: */
407 if (fstat(ifd, &sb) < 0) return Z_ERRNO;
408 buf_len = sb.st_size;
409 if (buf_len <= 0) return Z_ERRNO;
410
411 /* Now do the actual mmap: */
412 buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0);
413 if (buf == (caddr_t)(-1)) return Z_ERRNO;
414
415 /* Compress the whole file at once: */
416 len = gzwrite(out, (char *)buf, (unsigned)buf_len);
417
418 if (len != (int)buf_len) error(gzerror(out, &err));
419
420 munmap(buf, buf_len);
421 fclose(in);
422 if (gzclose(out) != Z_OK) error("failed gzclose");
423 return Z_OK;
424 }
425 #endif /* USE_MMAP */
426
427 /* ===========================================================================
428 * Uncompress input to output then close both files.
429 */
430 void gz_uncompress(in, out)
431 gzFile in;
432 FILE *out;
433 {
434 local char buf[BUFLEN];
435 int len;
436 int err;
437
438 for (;;) {
439 len = gzread(in, buf, sizeof(buf));
440 if (len < 0) error (gzerror(in, &err));
441 if (len == 0) break;
442
443 if ((int)fwrite(buf, 1, (unsigned)len, out) != len) {
444 error("failed fwrite");
445 }
446 }
447 if (fclose(out)) error("failed fclose");
448
449 if (gzclose(in) != Z_OK) error("failed gzclose");
450 }
451
452
453 /* ===========================================================================
454 * Compress the given file: create a corresponding .gz file and remove the
455 * original.
456 */
457 void file_compress(file, mode)
458 char *file;
459 char *mode;
460 {
461 local char outfile[MAX_NAME_LEN];
462 FILE *in;
463 gzFile out;
464
465 if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) {
466 fprintf(stderr, "%s: filename too long\n", prog);
467 exit(1);
468 }
469
470 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
471 snprintf(outfile, sizeof(outfile), "%s%s", file, GZ_SUFFIX);
472 #else
473 strcpy(outfile, file);
474 strcat(outfile, GZ_SUFFIX);
475 #endif
476
477 in = fopen(file, "rb");
478 if (in == NULL) {
479 perror(file);
480 exit(1);
481 }
482 out = gzopen(outfile, mode);
483 if (out == NULL) {
484 fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
485 exit(1);
486 }
487 gz_compress(in, out);
488
489 unlink(file);
490 }
491
492
493 /* ===========================================================================
494 * Uncompress the given file and remove the original.
495 */
496 void file_uncompress(file)
497 char *file;
498 {
499 local char buf[MAX_NAME_LEN];
500 char *infile, *outfile;
501 FILE *out;
502 gzFile in;
503 size_t len = strlen(file);
504
505 if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) {
506 fprintf(stderr, "%s: filename too long\n", prog);
507 exit(1);
508 }
509
510 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
511 snprintf(buf, sizeof(buf), "%s", file);
512 #else
513 strcpy(buf, file);
514 #endif
515
516 if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) {
517 infile = file;
518 outfile = buf;
519 outfile[len-3] = '\0';
520 } else {
521 outfile = file;
522 infile = buf;
523 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
524 snprintf(buf + len, sizeof(buf) - len, "%s", GZ_SUFFIX);
525 #else
526 strcat(infile, GZ_SUFFIX);
527 #endif
528 }
529 in = gzopen(infile, "rb");
530 if (in == NULL) {
531 fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
532 exit(1);
533 }
534 out = fopen(outfile, "wb");
535 if (out == NULL) {
536 perror(file);
537 exit(1);
538 }
539
540 gz_uncompress(in, out);
541
542 unlink(infile);
543 }
544
545
546 /* ===========================================================================
547 * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...]
548 * -c : write to standard output
549 * -d : decompress
550 * -f : compress with Z_FILTERED
551 * -h : compress with Z_HUFFMAN_ONLY
552 * -r : compress with Z_RLE
553 * -1 to -9 : compression level
554 */
555
556 int main(argc, argv)
557 int argc;
558 char *argv[];
559 {
560 int copyout = 0;
561 int uncompr = 0;
562 gzFile file;
563 char *bname, outmode[20];
564
565 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
566 snprintf(outmode, sizeof(outmode), "%s", "wb6 ");
567 #else
568 strcpy(outmode, "wb6 ");
569 #endif
570
571 prog = argv[0];
572 bname = strrchr(argv[0], '/');
573 if (bname)
574 bname++;
575 else
576 bname = argv[0];
577 argc--, argv++;
578
579 if (!strcmp(bname, "gunzip"))
580 uncompr = 1;
581 else if (!strcmp(bname, "zcat"))
582 copyout = uncompr = 1;
583
584 while (argc > 0) {
585 if (strcmp(*argv, "-c") == 0)
586 copyout = 1;
587 else if (strcmp(*argv, "-d") == 0)
588 uncompr = 1;
589 else if (strcmp(*argv, "-f") == 0)
590 outmode[3] = 'f';
591 else if (strcmp(*argv, "-h") == 0)
592 outmode[3] = 'h';
593 else if (strcmp(*argv, "-r") == 0)
594 outmode[3] = 'R';
595 else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
596 (*argv)[2] == 0)
597 outmode[2] = (*argv)[1];
598 else
599 break;
600 argc--, argv++;
601 }
602 if (outmode[3] == ' ')
603 outmode[3] = 0;
604 if (argc == 0) {
605 SET_BINARY_MODE(stdin);
606 SET_BINARY_MODE(stdout);
607 if (uncompr) {
608 file = gzdopen(fileno(stdin), "rb");
609 if (file == NULL) error("can't gzdopen stdin");
610 gz_uncompress(file, stdout);
611 } else {
612 file = gzdopen(fileno(stdout), outmode);
613 if (file == NULL) error("can't gzdopen stdout");
614 gz_compress(stdin, file);
615 }
616 } else {
617 if (copyout) {
618 SET_BINARY_MODE(stdout);
619 }
620 do {
621 if (uncompr) {
622 if (copyout) {
623 file = gzopen(*argv, "rb");
624 if (file == NULL)
625 fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv);
626 else
627 gz_uncompress(file, stdout);
628 } else {
629 file_uncompress(*argv);
630 }
631 } else {
632 if (copyout) {
633 FILE * in = fopen(*argv, "rb");
634
635 if (in == NULL) {
636 perror(*argv);
637 } else {
638 file = gzdopen(fileno(stdout), outmode);
639 if (file == NULL) error("can't gzdopen stdout");
640
641 gz_compress(in, file);
642 }
643
644 } else {
645 file_compress(*argv, outmode);
646 }
647 }
648 } while (argv++, --argc);
649 }
650 return 0;
651 }