1 /* example.c -- usage example of the zlib compression library

     2  * Copyright (C) 1995-1998 Jean-loup Gailly.

     3  * For conditions of distribution and use, see copyright notice in zlib.h 

     4  */

     5 

     6 /* @(#) $Id$ */

     7 

     8 #include <stdio.h>

     9 #include "zlib.h"

    10 

    11 #ifdef STDC

    12 #  include <string.h>

    13 #  include <stdlib.h>

    14 #else

    15    extern void exit  OF((int));

    16 #endif

    17 

    18 #if defined(VMS) || defined(RISCOS)

    19 #  define TESTFILE "foo-gz"

    20 #else

    21 #  define TESTFILE "foo.gz"

    22 #endif

    23 

    24 #define CHECK_ERR(err, msg) { \

    25     if (err != Z_OK) { \

    26         fprintf(stderr, "%s error: %d\n", msg, err); \

    27         exit(1); \

    28     } \

    29 }

    30 

    31 const char hello[] = "hello, hello!";

    32 /* "hello world" would be more standard, but the repeated "hello"

    33  * stresses the compression code better, sorry...

    34  */

    35 

    36 const char dictionary[] = "hello";

    37 uLong dictId; /* Adler32 value of the dictionary */

    38 

    39 void test_compress      OF((Byte *compr, uLong comprLen,

    40 		            Byte *uncompr, uLong uncomprLen));

    41 void test_gzio          OF((const char *out, const char *in, 

    42 		            Byte *uncompr, int uncomprLen));

    43 void test_deflate       OF((Byte *compr, uLong comprLen));

    44 void test_inflate       OF((Byte *compr, uLong comprLen,

    45 		            Byte *uncompr, uLong uncomprLen));

    46 void test_large_deflate OF((Byte *compr, uLong comprLen,

    47 		            Byte *uncompr, uLong uncomprLen));

    48 void test_large_inflate OF((Byte *compr, uLong comprLen,

    49 		            Byte *uncompr, uLong uncomprLen));

    50 void test_flush         OF((Byte *compr, uLong *comprLen));

    51 void test_sync          OF((Byte *compr, uLong comprLen,

    52 		            Byte *uncompr, uLong uncomprLen));

    53 void test_dict_deflate  OF((Byte *compr, uLong comprLen));

    54 void test_dict_inflate  OF((Byte *compr, uLong comprLen,

    55 		            Byte *uncompr, uLong uncomprLen));

    56 int  main               OF((int argc, char *argv[]));

    57 

    58 /* ===========================================================================

    59  * Test compress() and uncompress()

    60  */

    61 void test_compress(compr, comprLen, uncompr, uncomprLen)

    62     Byte *compr, *uncompr;

    63     uLong comprLen, uncomprLen;

    64 {

    65     int err;

    66     uLong len = strlen(hello)+1;

    67 

    68     err = compress(compr, &comprLen, (const Bytef*)hello, len);

    69     CHECK_ERR(err, "compress");

    70 

    71     strcpy((char*)uncompr, "garbage");

    72 

    73     err = uncompress(uncompr, &uncomprLen, compr, comprLen);

    74     CHECK_ERR(err, "uncompress");

    75 

    76     if (strcmp((char*)uncompr, hello)) {

    77         fprintf(stderr, "bad uncompress\n");

    78 	exit(1);

    79     } else {

    80         printf("uncompress(): %s\n", (char *)uncompr);

    81     }

    82 }

    83 

    84 /* ===========================================================================

    85  * Test read/write of .gz files

    86  */

    87 void test_gzio(out, in, uncompr, uncomprLen)

    88     const char *out; /* compressed output file */

    89     const char *in;  /* compressed input file */

    90     Byte *uncompr;

    91     int  uncomprLen;

    92 {

    93     int err;

    94     int len = strlen(hello)+1;

    95     gzFile file;

    96     z_off_t pos;

    97 

    98     file = gzopen(out, "wb");

    99     if (file == NULL) {

   100         fprintf(stderr, "gzopen error\n");

   101         exit(1);

   102     }

   103     gzputc(file, 'h');

   104     if (gzputs(file, "ello") != 4) {

   105         fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));

   106 	exit(1);

   107     }

   108     if (gzprintf(file, ", %s!", "hello") != 8) {

   109         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

   110 	exit(1);

   111     }

   112     gzseek(file, 1L, SEEK_CUR); /* add one zero byte */

   113     gzclose(file);

   114 

   115     file = gzopen(in, "rb");

   116     if (file == NULL) {

   117         fprintf(stderr, "gzopen error\n");

   118     }

   119     strcpy((char*)uncompr, "garbage");

   120 

   121     uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen);

   122     if (uncomprLen != len) {

   123         fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));

   124 	exit(1);

   125     }

   126     if (strcmp((char*)uncompr, hello)) {

   127         fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);

   128 	exit(1);

   129     } else {

   130         printf("gzread(): %s\n", (char *)uncompr);

   131     }

   132 

   133     pos = gzseek(file, -8L, SEEK_CUR);

   134     if (pos != 6 || gztell(file) != pos) {

   135 	fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",

   136 		(long)pos, (long)gztell(file));

   137 	exit(1);

   138     }

   139 

   140     if (gzgetc(file) != ' ') {

   141 	fprintf(stderr, "gzgetc error\n");

   142 	exit(1);

   143     }

   144 

   145     gzgets(file, (char*)uncompr, uncomprLen);

   146     uncomprLen = strlen((char*)uncompr);

   147     if (uncomprLen != 6) { /* "hello!" */

   148         fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));

   149 	exit(1);

   150     }

   151     if (strcmp((char*)uncompr, hello+7)) {

   152         fprintf(stderr, "bad gzgets after gzseek\n");

   153 	exit(1);

   154     } else {

   155         printf("gzgets() after gzseek: %s\n", (char *)uncompr);

   156     }

   157 

   158     gzclose(file);

   159 }

   160 

   161 /* ===========================================================================

   162  * Test deflate() with small buffers

   163  */

   164 void test_deflate(compr, comprLen)

   165     Byte *compr;

   166     uLong comprLen;

   167 {

   168     z_stream c_stream; /* compression stream */

   169     int err;

   170     int len = strlen(hello)+1;

   171 

   172     c_stream.zalloc = (alloc_func)0;

   173     c_stream.zfree = (free_func)0;

   174     c_stream.opaque = (voidpf)0;

   175 

   176     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

   177     CHECK_ERR(err, "deflateInit");

   178 

   179     c_stream.next_in  = (Bytef*)hello;

   180     c_stream.next_out = compr;

   181 

   182     while (c_stream.total_in != (uLong)len && c_stream.total_out < comprLen) {

   183         c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */

   184         err = deflate(&c_stream, Z_NO_FLUSH);

   185         CHECK_ERR(err, "deflate");

   186     }

   187     /* Finish the stream, still forcing small buffers: */

   188     for (;;) {

   189         c_stream.avail_out = 1;

   190         err = deflate(&c_stream, Z_FINISH);

   191         if (err == Z_STREAM_END) break;

   192         CHECK_ERR(err, "deflate");

   193     }

   194 

   195     err = deflateEnd(&c_stream);

   196     CHECK_ERR(err, "deflateEnd");

   197 }

   198 

   199 /* ===========================================================================

   200  * Test inflate() with small buffers

   201  */

   202 void test_inflate(compr, comprLen, uncompr, uncomprLen)

   203     Byte *compr, *uncompr;

   204     uLong comprLen, uncomprLen;

   205 {

   206     int err;

   207     z_stream d_stream; /* decompression stream */

   208 

   209     strcpy((char*)uncompr, "garbage");

   210 

   211     d_stream.zalloc = (alloc_func)0;

   212     d_stream.zfree = (free_func)0;

   213     d_stream.opaque = (voidpf)0;

   214 

   215     d_stream.next_in  = compr;

   216     d_stream.avail_in = 0;

   217     d_stream.next_out = uncompr;

   218 

   219     err = inflateInit(&d_stream);

   220     CHECK_ERR(err, "inflateInit");

   221 

   222     while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {

   223         d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */

   224         err = inflate(&d_stream, Z_NO_FLUSH);

   225         if (err == Z_STREAM_END) break;

   226         CHECK_ERR(err, "inflate");

   227     }

   228 

   229     err = inflateEnd(&d_stream);

   230     CHECK_ERR(err, "inflateEnd");

   231 

   232     if (strcmp((char*)uncompr, hello)) {

   233         fprintf(stderr, "bad inflate\n");

   234 	exit(1);

   235     } else {

   236         printf("inflate(): %s\n", (char *)uncompr);

   237     }

   238 }

   239 

   240 /* ===========================================================================

   241  * Test deflate() with large buffers and dynamic change of compression level

   242  */

   243 void test_large_deflate(compr, comprLen, uncompr, uncomprLen)

   244     Byte *compr, *uncompr;

   245     uLong comprLen, uncomprLen;

   246 {

   247     z_stream c_stream; /* compression stream */

   248     int err;

   249 

   250     c_stream.zalloc = (alloc_func)0;

   251     c_stream.zfree = (free_func)0;

   252     c_stream.opaque = (voidpf)0;

   253 

   254     err = deflateInit(&c_stream, Z_BEST_SPEED);

   255     CHECK_ERR(err, "deflateInit");

   256 

   257     c_stream.next_out = compr;

   258     c_stream.avail_out = (uInt)comprLen;

   259 

   260     /* At this point, uncompr is still mostly zeroes, so it should compress

   261      * very well:

   262      */

   263     c_stream.next_in = uncompr;

   264     c_stream.avail_in = (uInt)uncomprLen;

   265     err = deflate(&c_stream, Z_NO_FLUSH);

   266     CHECK_ERR(err, "deflate");

   267     if (c_stream.avail_in != 0) {

   268         fprintf(stderr, "deflate not greedy\n");

   269 	exit(1);

   270     }

   271 

   272     /* Feed in already compressed data and switch to no compression: */

   273     deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);

   274     c_stream.next_in = compr;

   275     c_stream.avail_in = (uInt)comprLen/2;

   276     err = deflate(&c_stream, Z_NO_FLUSH);

   277     CHECK_ERR(err, "deflate");

   278 

   279     /* Switch back to compressing mode: */

   280     deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);

   281     c_stream.next_in = uncompr;

   282     c_stream.avail_in = (uInt)uncomprLen;

   283     err = deflate(&c_stream, Z_NO_FLUSH);

   284     CHECK_ERR(err, "deflate");

   285 

   286     err = deflate(&c_stream, Z_FINISH);

   287     if (err != Z_STREAM_END) {

   288         fprintf(stderr, "deflate should report Z_STREAM_END\n");

   289 	exit(1);

   290     }

   291     err = deflateEnd(&c_stream);

   292     CHECK_ERR(err, "deflateEnd");

   293 }

   294 

   295 /* ===========================================================================

   296  * Test inflate() with large buffers

   297  */

   298 void test_large_inflate(compr, comprLen, uncompr, uncomprLen)

   299     Byte *compr, *uncompr;

   300     uLong comprLen, uncomprLen;

   301 {

   302     int err;

   303     z_stream d_stream; /* decompression stream */

   304 

   305     strcpy((char*)uncompr, "garbage");

   306 

   307     d_stream.zalloc = (alloc_func)0;

   308     d_stream.zfree = (free_func)0;

   309     d_stream.opaque = (voidpf)0;

   310 

   311     d_stream.next_in  = compr;

   312     d_stream.avail_in = (uInt)comprLen;

   313 

   314     err = inflateInit(&d_stream);

   315     CHECK_ERR(err, "inflateInit");

   316 

   317     for (;;) {

   318         d_stream.next_out = uncompr;            /* discard the output */

   319 	d_stream.avail_out = (uInt)uncomprLen;

   320         err = inflate(&d_stream, Z_NO_FLUSH);

   321         if (err == Z_STREAM_END) break;

   322         CHECK_ERR(err, "large inflate");

   323     }

   324 

   325     err = inflateEnd(&d_stream);

   326     CHECK_ERR(err, "inflateEnd");

   327 

   328     if (d_stream.total_out != 2*uncomprLen + comprLen/2) {

   329         fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);

   330 	exit(1);

   331     } else {

   332         printf("large_inflate(): OK\n");

   333     }

   334 }

   335 

   336 /* ===========================================================================

   337  * Test deflate() with full flush

   338  */

   339 void test_flush(compr, comprLen)

   340     Byte *compr;

   341     uLong *comprLen;

   342 {

   343     z_stream c_stream; /* compression stream */

   344     int err;

   345     int len = strlen(hello)+1;

   346 

   347     c_stream.zalloc = (alloc_func)0;

   348     c_stream.zfree = (free_func)0;

   349     c_stream.opaque = (voidpf)0;

   350 

   351     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

   352     CHECK_ERR(err, "deflateInit");

   353 

   354     c_stream.next_in  = (Bytef*)hello;

   355     c_stream.next_out = compr;

   356     c_stream.avail_in = 3;

   357     c_stream.avail_out = (uInt)*comprLen;

   358     err = deflate(&c_stream, Z_FULL_FLUSH);

   359     CHECK_ERR(err, "deflate");

   360 

   361     compr[3]++; /* force an error in first compressed block */

   362     c_stream.avail_in = len - 3;

   363 

   364     err = deflate(&c_stream, Z_FINISH);

   365     if (err != Z_STREAM_END) {

   366         CHECK_ERR(err, "deflate");

   367     }

   368     err = deflateEnd(&c_stream);

   369     CHECK_ERR(err, "deflateEnd");

   370 

   371     *comprLen = c_stream.total_out;

   372 }

   373 

   374 /* ===========================================================================

   375  * Test inflateSync()

   376  */

   377 void test_sync(compr, comprLen, uncompr, uncomprLen)

   378     Byte *compr, *uncompr;

   379     uLong comprLen, uncomprLen;

   380 {

   381     int err;

   382     z_stream d_stream; /* decompression stream */

   383 

   384     strcpy((char*)uncompr, "garbage");

   385 

   386     d_stream.zalloc = (alloc_func)0;

   387     d_stream.zfree = (free_func)0;

   388     d_stream.opaque = (voidpf)0;

   389 

   390     d_stream.next_in  = compr;

   391     d_stream.avail_in = 2; /* just read the zlib header */

   392 

   393     err = inflateInit(&d_stream);

   394     CHECK_ERR(err, "inflateInit");

   395 

   396     d_stream.next_out = uncompr;

   397     d_stream.avail_out = (uInt)uncomprLen;

   398 

   399     inflate(&d_stream, Z_NO_FLUSH);

   400     CHECK_ERR(err, "inflate");

   401 

   402     d_stream.avail_in = (uInt)comprLen-2;   /* read all compressed data */

   403     err = inflateSync(&d_stream);           /* but skip the damaged part */

   404     CHECK_ERR(err, "inflateSync");

   405 

   406     err = inflate(&d_stream, Z_FINISH);

   407     if (err != Z_DATA_ERROR) {

   408         fprintf(stderr, "inflate should report DATA_ERROR\n");

   409         /* Because of incorrect adler32 */

   410 	exit(1);

   411     }

   412     err = inflateEnd(&d_stream);

   413     CHECK_ERR(err, "inflateEnd");

   414 

   415     printf("after inflateSync(): hel%s\n", (char *)uncompr);

   416 }

   417 

   418 /* ===========================================================================

   419  * Test deflate() with preset dictionary

   420  */

   421 void test_dict_deflate(compr, comprLen)

   422     Byte *compr;

   423     uLong comprLen;

   424 {

   425     z_stream c_stream; /* compression stream */

   426     int err;

   427 

   428     c_stream.zalloc = (alloc_func)0;

   429     c_stream.zfree = (free_func)0;

   430     c_stream.opaque = (voidpf)0;

   431 

   432     err = deflateInit(&c_stream, Z_BEST_COMPRESSION);

   433     CHECK_ERR(err, "deflateInit");

   434 

   435     err = deflateSetDictionary(&c_stream,

   436 			       (const Bytef*)dictionary, sizeof(dictionary));

   437     CHECK_ERR(err, "deflateSetDictionary");

   438 

   439     dictId = c_stream.adler;

   440     c_stream.next_out = compr;

   441     c_stream.avail_out = (uInt)comprLen;

   442 

   443     c_stream.next_in = (Bytef*)hello;

   444     c_stream.avail_in = (uInt)strlen(hello)+1;

   445 

   446     err = deflate(&c_stream, Z_FINISH);

   447     if (err != Z_STREAM_END) {

   448         fprintf(stderr, "deflate should report Z_STREAM_END\n");

   449 	exit(1);

   450     }

   451     err = deflateEnd(&c_stream);

   452     CHECK_ERR(err, "deflateEnd");

   453 }

   454 

   455 /* ===========================================================================

   456  * Test inflate() with a preset dictionary

   457  */

   458 void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)

   459     Byte *compr, *uncompr;

   460     uLong comprLen, uncomprLen;

   461 {

   462     int err;

   463     z_stream d_stream; /* decompression stream */

   464 

   465     strcpy((char*)uncompr, "garbage");

   466 

   467     d_stream.zalloc = (alloc_func)0;

   468     d_stream.zfree = (free_func)0;

   469     d_stream.opaque = (voidpf)0;

   470 

   471     d_stream.next_in  = compr;

   472     d_stream.avail_in = (uInt)comprLen;

   473 

   474     err = inflateInit(&d_stream);

   475     CHECK_ERR(err, "inflateInit");

   476 

   477     d_stream.next_out = uncompr;

   478     d_stream.avail_out = (uInt)uncomprLen;

   479 

   480     for (;;) {

   481         err = inflate(&d_stream, Z_NO_FLUSH);

   482         if (err == Z_STREAM_END) break;

   483 	if (err == Z_NEED_DICT) {

   484 	    if (d_stream.adler != dictId) {

   485 		fprintf(stderr, "unexpected dictionary");

   486 		exit(1);

   487 	    }

   488 	    err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,

   489 				       sizeof(dictionary));

   490 	}

   491         CHECK_ERR(err, "inflate with dict");

   492     }

   493 

   494     err = inflateEnd(&d_stream);

   495     CHECK_ERR(err, "inflateEnd");

   496 

   497     if (strcmp((char*)uncompr, hello)) {

   498         fprintf(stderr, "bad inflate with dict\n");

   499 	exit(1);

   500     } else {

   501         printf("inflate with dictionary: %s\n", (char *)uncompr);

   502     }

   503 }

   504 

   505 /* ===========================================================================

   506  * Usage:  example [output.gz  [input.gz]]

   507  */

   508 

   509 int main(argc, argv)

   510     int argc;

   511     char *argv[];

   512 {

   513     Byte *compr, *uncompr;

   514     uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */

   515     uLong uncomprLen = comprLen;

   516     static const char* myVersion = ZLIB_VERSION;

   517 

   518     if (zlibVersion()[0] != myVersion[0]) {

   519         fprintf(stderr, "incompatible zlib version\n");

   520         exit(1);

   521 

   522     } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {

   523         fprintf(stderr, "warning: different zlib version\n");

   524     }

   525 

   526     compr    = (Byte*)calloc((uInt)comprLen, 1);

   527     uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   528     /* compr and uncompr are cleared to avoid reading uninitialized

   529      * data and to ensure that uncompr compresses well.

   530      */

   531     if (compr == Z_NULL || uncompr == Z_NULL) {

   532         printf("out of memory\n");

   533 	exit(1);

   534     }

   535     test_compress(compr, comprLen, uncompr, uncomprLen);

   536 

   537     test_gzio((argc > 1 ? argv[1] : TESTFILE),

   538               (argc > 2 ? argv[2] : TESTFILE),

   539 	      uncompr, (int)uncomprLen);

   540 

   541     test_deflate(compr, comprLen);

   542     test_inflate(compr, comprLen, uncompr, uncomprLen);

   543 

   544     test_large_deflate(compr, comprLen, uncompr, uncomprLen);

   545     test_large_inflate(compr, comprLen, uncompr, uncomprLen);

   546 

   547     test_flush(compr, &comprLen);

   548     test_sync(compr, comprLen, uncompr, uncomprLen);

   549     comprLen = uncomprLen;

   550 

   551     test_dict_deflate(compr, comprLen);

   552     test_dict_inflate(compr, comprLen, uncompr, uncomprLen);

   553 

   554     exit(0);

   555     return 0; /* to avoid warning */

   556 }