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

     2  * Copyright (C) 1995-2004 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 #endif

    15 

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

    17 #  define TESTFILE "foo-gz"

    18 #else

    19 #  define TESTFILE "foo.gz"

    20 #endif

    21 

    22 #define CHECK_ERR(err, msg) { \

    23     if (err != Z_OK) { \

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

    25         exit(1); \

    26     } \

    27 }

    28 

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

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

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

    32  */

    33 

    34 const char dictionary[] = "hello";

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

    36 

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

    38                             Byte *uncompr, uLong uncomprLen));

    39 void test_gzio          OF((const char *fname,

    40                             Byte *uncompr, uLong uncomprLen));

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

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

    43                             Byte *uncompr, uLong uncomprLen));

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

    45                             Byte *uncompr, uLong uncomprLen));

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

    47                             Byte *uncompr, uLong uncomprLen));

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

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

    50                             Byte *uncompr, uLong uncomprLen));

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

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

    53                             Byte *uncompr, uLong uncomprLen));

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

    55 

    56 /* ===========================================================================

    57  * Test compress() and uncompress()

    58  */

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

    60     Byte *compr, *uncompr;

    61     uLong comprLen, uncomprLen;

    62 {

    63     int err;

    64     uLong len = (uLong)strlen(hello)+1;

    65 

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

    67     CHECK_ERR(err, "compress");

    68 

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

    70 

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

    72     CHECK_ERR(err, "uncompress");

    73 

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

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

    76         exit(1);

    77     } else {

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

    79     }

    80 }

    81 

    82 /* ===========================================================================

    83  * Test read/write of .gz files

    84  */

    85 void test_gzio(fname, uncompr, uncomprLen)

    86     const char *fname; /* compressed file name */

    87     Byte *uncompr;

    88     uLong uncomprLen;

    89 {

    90 #ifdef NO_GZCOMPRESS

    91     fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");

    92 #else

    93     int err;

    94     int len = (int)strlen(hello)+1;

    95     gzFile file;

    96     z_off_t pos;

    97 

    98     file = gzopen(fname, "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(fname, "rb");

   116     if (file == NULL) {

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

   118         exit(1);

   119     }

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

   121 

   122     if (gzread(file, uncompr, (unsigned)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     if (gzungetc(' ', file) != ' ') {

   146         fprintf(stderr, "gzungetc error\n");

   147         exit(1);

   148     }

   149 

   150     gzgets(file, (char*)uncompr, (int)uncomprLen);

   151     if (strlen((char*)uncompr) != 7) { /* " hello!" */

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

   153         exit(1);

   154     }

   155     if (strcmp((char*)uncompr, hello + 6)) {

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

   157         exit(1);

   158     } else {

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

   160     }

   161 

   162     gzclose(file);

   163 #endif

   164 }

   165 

   166 /* ===========================================================================

   167  * Test deflate() with small buffers

   168  */

   169 void test_deflate(compr, comprLen)

   170     Byte *compr;

   171     uLong comprLen;

   172 {

   173     z_stream c_stream; /* compression stream */

   174     int err;

   175     uLong len = (uLong)strlen(hello)+1;

   176 

   177     c_stream.zalloc = (alloc_func)0;

   178     c_stream.zfree = (free_func)0;

   179     c_stream.opaque = (voidpf)0;

   180 

   181     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

   182     CHECK_ERR(err, "deflateInit");

   183 

   184     c_stream.next_in  = (Bytef*)hello;

   185     c_stream.next_out = compr;

   186 

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

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

   189         err = deflate(&c_stream, Z_NO_FLUSH);

   190         CHECK_ERR(err, "deflate");

   191     }

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

   193     for (;;) {

   194         c_stream.avail_out = 1;

   195         err = deflate(&c_stream, Z_FINISH);

   196         if (err == Z_STREAM_END) break;

   197         CHECK_ERR(err, "deflate");

   198     }

   199 

   200     err = deflateEnd(&c_stream);

   201     CHECK_ERR(err, "deflateEnd");

   202 }

   203 

   204 /* ===========================================================================

   205  * Test inflate() with small buffers

   206  */

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

   208     Byte *compr, *uncompr;

   209     uLong comprLen, uncomprLen;

   210 {

   211     int err;

   212     z_stream d_stream; /* decompression stream */

   213 

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

   215 

   216     d_stream.zalloc = (alloc_func)0;

   217     d_stream.zfree = (free_func)0;

   218     d_stream.opaque = (voidpf)0;

   219 

   220     d_stream.next_in  = compr;

   221     d_stream.avail_in = 0;

   222     d_stream.next_out = uncompr;

   223 

   224     err = inflateInit(&d_stream);

   225     CHECK_ERR(err, "inflateInit");

   226 

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

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

   229         err = inflate(&d_stream, Z_NO_FLUSH);

   230         if (err == Z_STREAM_END) break;

   231         CHECK_ERR(err, "inflate");

   232     }

   233 

   234     err = inflateEnd(&d_stream);

   235     CHECK_ERR(err, "inflateEnd");

   236 

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

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

   239         exit(1);

   240     } else {

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

   242     }

   243 }

   244 

   245 /* ===========================================================================

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

   247  */

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

   249     Byte *compr, *uncompr;

   250     uLong comprLen, uncomprLen;

   251 {

   252     z_stream c_stream; /* compression stream */

   253     int err;

   254 

   255     c_stream.zalloc = (alloc_func)0;

   256     c_stream.zfree = (free_func)0;

   257     c_stream.opaque = (voidpf)0;

   258 

   259     err = deflateInit(&c_stream, Z_BEST_SPEED);

   260     CHECK_ERR(err, "deflateInit");

   261 

   262     c_stream.next_out = compr;

   263     c_stream.avail_out = (uInt)comprLen;

   264 

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

   266      * very well:

   267      */

   268     c_stream.next_in = uncompr;

   269     c_stream.avail_in = (uInt)uncomprLen;

   270     err = deflate(&c_stream, Z_NO_FLUSH);

   271     CHECK_ERR(err, "deflate");

   272     if (c_stream.avail_in != 0) {

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

   274         exit(1);

   275     }

   276 

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

   278     deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);

   279     c_stream.next_in = compr;

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

   281     err = deflate(&c_stream, Z_NO_FLUSH);

   282     CHECK_ERR(err, "deflate");

   283 

   284     /* Switch back to compressing mode: */

   285     deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);

   286     c_stream.next_in = uncompr;

   287     c_stream.avail_in = (uInt)uncomprLen;

   288     err = deflate(&c_stream, Z_NO_FLUSH);

   289     CHECK_ERR(err, "deflate");

   290 

   291     err = deflate(&c_stream, Z_FINISH);

   292     if (err != Z_STREAM_END) {

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

   294         exit(1);

   295     }

   296     err = deflateEnd(&c_stream);

   297     CHECK_ERR(err, "deflateEnd");

   298 }

   299 

   300 /* ===========================================================================

   301  * Test inflate() with large buffers

   302  */

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

   304     Byte *compr, *uncompr;

   305     uLong comprLen, uncomprLen;

   306 {

   307     int err;

   308     z_stream d_stream; /* decompression stream */

   309 

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

   311 

   312     d_stream.zalloc = (alloc_func)0;

   313     d_stream.zfree = (free_func)0;

   314     d_stream.opaque = (voidpf)0;

   315 

   316     d_stream.next_in  = compr;

   317     d_stream.avail_in = (uInt)comprLen;

   318 

   319     err = inflateInit(&d_stream);

   320     CHECK_ERR(err, "inflateInit");

   321 

   322     for (;;) {

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

   324         d_stream.avail_out = (uInt)uncomprLen;

   325         err = inflate(&d_stream, Z_NO_FLUSH);

   326         if (err == Z_STREAM_END) break;

   327         CHECK_ERR(err, "large inflate");

   328     }

   329 

   330     err = inflateEnd(&d_stream);

   331     CHECK_ERR(err, "inflateEnd");

   332 

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

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

   335         exit(1);

   336     } else {

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

   338     }

   339 }

   340 

   341 /* ===========================================================================

   342  * Test deflate() with full flush

   343  */

   344 void test_flush(compr, comprLen)

   345     Byte *compr;

   346     uLong *comprLen;

   347 {

   348     z_stream c_stream; /* compression stream */

   349     int err;

   350     uInt len = (uInt)strlen(hello)+1;

   351 

   352     c_stream.zalloc = (alloc_func)0;

   353     c_stream.zfree = (free_func)0;

   354     c_stream.opaque = (voidpf)0;

   355 

   356     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

   357     CHECK_ERR(err, "deflateInit");

   358 

   359     c_stream.next_in  = (Bytef*)hello;

   360     c_stream.next_out = compr;

   361     c_stream.avail_in = 3;

   362     c_stream.avail_out = (uInt)*comprLen;

   363     err = deflate(&c_stream, Z_FULL_FLUSH);

   364     CHECK_ERR(err, "deflate");

   365 

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

   367     c_stream.avail_in = len - 3;

   368 

   369     err = deflate(&c_stream, Z_FINISH);

   370     if (err != Z_STREAM_END) {

   371         CHECK_ERR(err, "deflate");

   372     }

   373     err = deflateEnd(&c_stream);

   374     CHECK_ERR(err, "deflateEnd");

   375 

   376     *comprLen = c_stream.total_out;

   377 }

   378 

   379 /* ===========================================================================

   380  * Test inflateSync()

   381  */

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

   383     Byte *compr, *uncompr;

   384     uLong comprLen, uncomprLen;

   385 {

   386     int err;

   387     z_stream d_stream; /* decompression stream */

   388 

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

   390 

   391     d_stream.zalloc = (alloc_func)0;

   392     d_stream.zfree = (free_func)0;

   393     d_stream.opaque = (voidpf)0;

   394 

   395     d_stream.next_in  = compr;

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

   397 

   398     err = inflateInit(&d_stream);

   399     CHECK_ERR(err, "inflateInit");

   400 

   401     d_stream.next_out = uncompr;

   402     d_stream.avail_out = (uInt)uncomprLen;

   403 

   404     inflate(&d_stream, Z_NO_FLUSH);

   405     CHECK_ERR(err, "inflate");

   406 

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

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

   409     CHECK_ERR(err, "inflateSync");

   410 

   411     err = inflate(&d_stream, Z_FINISH);

   412     if (err != Z_DATA_ERROR) {

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

   414         /* Because of incorrect adler32 */

   415         exit(1);

   416     }

   417     err = inflateEnd(&d_stream);

   418     CHECK_ERR(err, "inflateEnd");

   419 

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

   421 }

   422 

   423 /* ===========================================================================

   424  * Test deflate() with preset dictionary

   425  */

   426 void test_dict_deflate(compr, comprLen)

   427     Byte *compr;

   428     uLong comprLen;

   429 {

   430     z_stream c_stream; /* compression stream */

   431     int err;

   432 

   433     c_stream.zalloc = (alloc_func)0;

   434     c_stream.zfree = (free_func)0;

   435     c_stream.opaque = (voidpf)0;

   436 

   437     err = deflateInit(&c_stream, Z_BEST_COMPRESSION);

   438     CHECK_ERR(err, "deflateInit");

   439 

   440     err = deflateSetDictionary(&c_stream,

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

   442     CHECK_ERR(err, "deflateSetDictionary");

   443 

   444     dictId = c_stream.adler;

   445     c_stream.next_out = compr;

   446     c_stream.avail_out = (uInt)comprLen;

   447 

   448     c_stream.next_in = (Bytef*)hello;

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

   450 

   451     err = deflate(&c_stream, Z_FINISH);

   452     if (err != Z_STREAM_END) {

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

   454         exit(1);

   455     }

   456     err = deflateEnd(&c_stream);

   457     CHECK_ERR(err, "deflateEnd");

   458 }

   459 

   460 /* ===========================================================================

   461  * Test inflate() with a preset dictionary

   462  */

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

   464     Byte *compr, *uncompr;

   465     uLong comprLen, uncomprLen;

   466 {

   467     int err;

   468     z_stream d_stream; /* decompression stream */

   469 

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

   471 

   472     d_stream.zalloc = (alloc_func)0;

   473     d_stream.zfree = (free_func)0;

   474     d_stream.opaque = (voidpf)0;

   475 

   476     d_stream.next_in  = compr;

   477     d_stream.avail_in = (uInt)comprLen;

   478 

   479     err = inflateInit(&d_stream);

   480     CHECK_ERR(err, "inflateInit");

   481 

   482     d_stream.next_out = uncompr;

   483     d_stream.avail_out = (uInt)uncomprLen;

   484 

   485     for (;;) {

   486         err = inflate(&d_stream, Z_NO_FLUSH);

   487         if (err == Z_STREAM_END) break;

   488         if (err == Z_NEED_DICT) {

   489             if (d_stream.adler != dictId) {

   490                 fprintf(stderr, "unexpected dictionary");

   491                 exit(1);

   492             }

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

   494                                        sizeof(dictionary));

   495         }

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

   497     }

   498 

   499     err = inflateEnd(&d_stream);

   500     CHECK_ERR(err, "inflateEnd");

   501 

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

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

   504         exit(1);

   505     } else {

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

   507     }

   508 }

   509 

   510 /* ===========================================================================

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

   512  */

   513 

   514 int main(argc, argv)

   515     int argc;

   516     char *argv[];

   517 {

   518     Byte *compr, *uncompr;

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

   520     uLong uncomprLen = comprLen;

   521     static const char* myVersion = ZLIB_VERSION;

   522 

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

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

   525         exit(1);

   526 

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

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

   529     }

   530 

   531     printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",

   532             ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());

   533 

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

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

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

   537      * data and to ensure that uncompr compresses well.

   538      */

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

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

   541         exit(1);

   542     }

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

   544 

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

   546               uncompr, uncomprLen);

   547 

   548     test_deflate(compr, comprLen);

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

   550 

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

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

   553 

   554     test_flush(compr, &comprLen);

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

   556     comprLen = uncomprLen;

   557 

   558     test_dict_deflate(compr, comprLen);

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

   560 

   561     free(compr);

   562     free(uncompr);

   563 

   564     return 0;

   565 }