toolchain/gcc/zlib/example.c

   1 /* example.c -- usage example of the zlib compression library
   2  * Copyright (C) 1995-2002 Jean-loup Gailly.
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  */
   5
   6 /* @(#) $Id: example.c 119 2004-10-05 20:38:42Z oyvind $ */
   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 }