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 } 652