|
111
|
1 /* minigzip.c -- simulate gzip using the zlib compression library
|
|
|
2 * Copyright (C) 1995-2006, 2010, 2011, 2016 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 #if defined(_MSC_VER) && _MSC_VER < 1900
|
|
|
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 (void)q;
|
|
|
160 return calloc(n, m);
|
|
|
161 }
|
|
|
162
|
|
|
163 void myfree(q, p)
|
|
|
164 void *q, *p;
|
|
|
165 {
|
|
|
166 (void)q;
|
|
|
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 static 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 unsigned 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 }
|
