sys/contrib/zstd/zlibWrapper/examples/minigzip.c

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