cpan/Compress-Raw-Zlib/Zlib.xs

   1 /* Filename: Zlib.xs
   2  * Author  : Paul Marquess, <pmqs@cpan.org>
   3  * Created : 22nd January 1996
   4  * Version : 2.000
   5  *
   6  *   Copyright (c) 1995-2013 Paul Marquess. All rights reserved.
   7  *   This program is free software; you can redistribute it and/or
   8  *   modify it under the same terms as Perl itself.
   9  *
  10  */
  11
  12 /* Parts of this code are based on the files gzio.c and gzappend.c from
  13  * the standard zlib source distribution. Below are the copyright statements
  14  * from each.
  15  */
  16
  17 /* gzio.c -- IO on .gz files
  18  * Copyright (C) 1995 Jean-loup Gailly.
  19  * For conditions of distribution and use, see copyright notice in zlib.h
  20  */
  21
  22 /* gzappend -- command to append to a gzip file
  23
  24   Copyright (C) 2003 Mark Adler, all rights reserved
  25   version 1.1, 4 Nov 2003
  26 */
  27
  28
  29 #define PERL_NO_GET_CONTEXT
  30 #include "EXTERN.h"
  31 #include "perl.h"
  32 #include "XSUB.h"
  33
  34 #include "zlib.h"
  35
  36 /* zlib prior to 1.06 doesn't know about z_off_t */
  37 #ifndef z_off_t
  38 #  define z_off_t   long
  39 #endif
  40
  41 #if  ! defined(ZLIB_VERNUM) || ZLIB_VERNUM < 0x1200
  42 #  define NEED_DUMMY_BYTE_AT_END
  43 #endif
  44
  45 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1210
  46 #  define MAGIC_APPEND
  47 #  define AT_LEAST_ZLIB_1_2_1
  48 #endif
  49
  50 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1221
  51 #  define AT_LEAST_ZLIB_1_2_2_1
  52 #endif
  53
  54 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1222
  55 #  define AT_LEAST_ZLIB_1_2_2_2
  56 #endif
  57
  58 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1223
  59 #  define AT_LEAST_ZLIB_1_2_2_3
  60 #endif
  61
  62 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230
  63 #  define AT_LEAST_ZLIB_1_2_3
  64 #endif
  65
  66 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1252
  67 /*
  68     Use Z_SOLO to build source means need own malloc/free
  69  */
  70 #  define AT_LEAST_ZLIB_1_2_5_2
  71 #endif
  72
  73 #if  defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1280
  74 #  define AT_LEAST_ZLIB_1_2_8
  75 #endif
  76
  77 #ifdef USE_PPPORT_H
  78 #  define NEED_sv_2pvbyte
  79 #  define NEED_sv_2pv_nolen
  80 #  define NEED_sv_pvn_force_flags
  81 #  include "ppport.h"
  82 #endif
  83
  84 #if PERL_REVISION == 5 && PERL_VERSION == 9
  85     /* For Andreas */
  86 #   define sv_pvbyte_force(sv,lp) sv_pvbyten_force(sv,lp)
  87 #endif
  88
  89 #if PERL_REVISION == 5 && (PERL_VERSION < 8 || (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
  90
  91 #    ifdef SvPVbyte_force
  92 #        undef SvPVbyte_force
  93 #    endif
  94
  95 #    define SvPVbyte_force(sv,lp) SvPV_force(sv,lp)
  96
  97 #endif
  98
  99 #ifndef SvPVbyte_nolen
 100 #    define SvPVbyte_nolen SvPV_nolen
 101 #endif
 102
 103
 104
 105 #if 0
 106 #  ifndef SvPVbyte_nolen
 107 #    define SvPVbyte_nolen SvPV_nolen
 108 #  endif
 109
 110 #  ifndef SvPVbyte_force
 111 #    define SvPVbyte_force(sv,lp) SvPV_force(sv,lp)
 112 #  endif
 113 #endif
 114
 115 #if PERL_REVISION == 5 && (PERL_VERSION >= 8 || (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
 116 #    define UTF8_AVAILABLE
 117 #endif
 118
 119 typedef int                     DualType ;
 120 typedef int                     int_undef ;
 121
 122 typedef struct di_stream {
 123     int      flags ;
 124 #define FLAG_APPEND             1
 125 #define FLAG_CRC32              2
 126 #define FLAG_ADLER32            4
 127 #define FLAG_CONSUME_INPUT      8
 128 #define FLAG_LIMIT_OUTPUT       16
 129     uLong    crc32 ;
 130     uLong    adler32 ;
 131     z_stream stream;
 132     uLong     bufsize;
 133     SV *     dictionary ;
 134     uLong    dict_adler ;
 135     int      last_error ;
 136     bool     zip_mode ;
 137 #define SETP_BYTE
 138 #ifdef SETP_BYTE
 139     bool     deflateParams_out_valid ;
 140     Bytef    deflateParams_out_byte;
 141 #else
 142 #define deflateParams_BUFFER_SIZE       0x4000
 143     uLong    deflateParams_out_length;
 144     Bytef*   deflateParams_out_buffer;
 145 #endif
 146     int      Level;
 147     int      Method;
 148     int      WindowBits;
 149     int      MemLevel;
 150     int      Strategy;
 151     uLong    bytesInflated ;
 152     uLong    compressedBytes ;
 153     uLong    uncompressedBytes ;
 154 #ifdef MAGIC_APPEND
 155
 156 #define WINDOW_SIZE 32768U
 157
 158     bool     matchedEndBlock;
 159     Bytef*   window ;
 160     int      window_lastbit,  window_left,  window_full;
 161     unsigned window_have;
 162     off_t    window_lastoff, window_end;
 163     off_t    window_endOffset;
 164
 165     uLong    lastBlockOffset ;
 166     unsigned char window_lastByte ;
 167
 168
 169 #endif
 170 } di_stream;
 171
 172 typedef di_stream * deflateStream ;
 173 typedef di_stream * Compress__Raw__Zlib__deflateStream ;
 174 typedef di_stream * inflateStream ;
 175 typedef di_stream * Compress__Raw__Zlib__inflateStream ;
 176 typedef di_stream * Compress__Raw__Zlib__inflateScanStream ;
 177
 178 #define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), \
 179                                 Zero(to,1,typ))
 180
 181 /* Figure out the Operating System */
 182 #ifdef MSDOS
 183 #  define OS_CODE  0x00
 184 #endif
 185
 186 #if defined(AMIGA) || defined(AMIGAOS)
 187 #  define OS_CODE  0x01
 188 #endif
 189
 190 #if defined(VAXC) || defined(VMS)
 191 #  define OS_CODE  0x02
 192 #endif
 193
 194 #if 0 /* VM/CMS */
 195 #  define OS_CODE  0x04
 196 #endif
 197
 198 #if defined(ATARI) || defined(atarist)
 199 #  define OS_CODE  0x05
 200 #endif
 201
 202 #ifdef OS2
 203 #  define OS_CODE  0x06
 204 #endif
 205
 206 #if defined(MACOS) || defined(TARGET_OS_MAC)
 207 #  define OS_CODE  0x07
 208 #endif
 209
 210 #if 0 /* Z-System */
 211 #  define OS_CODE  0x08
 212 #endif
 213
 214 #if 0 /* CP/M */
 215 #  define OS_CODE  0x09
 216 #endif
 217
 218 #ifdef TOPS20
 219 #  define OS_CODE  0x0a
 220 #endif
 221
 222 #ifdef WIN32 /* Window 95 & Windows NT */
 223 #  define OS_CODE  0x0b
 224 #endif
 225
 226 #if 0 /* QDOS */
 227 #  define OS_CODE  0x0c
 228 #endif
 229
 230 #if 0 /* Acorn RISCOS */
 231 #  define OS_CODE  0x0d
 232 #endif
 233
 234 #if 0 /* ???  */
 235 #  define OS_CODE  0x0e
 236 #endif
 237
 238 #ifdef __50SERIES /* Prime/PRIMOS */
 239 #  define OS_CODE  0x0F
 240 #endif
 241
 242 /* Default to UNIX */
 243 #ifndef OS_CODE
 244 #  define OS_CODE  0x03  /* assume Unix */
 245 #endif
 246
 247 #ifndef GZIP_OS_CODE
 248 #  define GZIP_OS_CODE OS_CODE
 249 #endif
 250
 251 #define adlerInitial adler32(0L, Z_NULL, 0)
 252 #define crcInitial crc32(0L, Z_NULL, 0)
 253
 254 /* static const char * const my_z_errmsg[] = { */
 255 static const char my_z_errmsg[][32] = {
 256     "need dictionary",     /* Z_NEED_DICT     2 */
 257     "stream end",          /* Z_STREAM_END    1 */
 258     "",                    /* Z_OK            0 */
 259     "file error",          /* Z_ERRNO        (-1) */
 260     "stream error",        /* Z_STREAM_ERROR (-2) */
 261     "data error",          /* Z_DATA_ERROR   (-3) */
 262     "insufficient memory", /* Z_MEM_ERROR    (-4) */
 263     "buffer error",        /* Z_BUF_ERROR    (-5) */
 264     "incompatible version",/* Z_VERSION_ERROR(-6) */
 265     ""};
 266
 267 #define setDUALstatus(var, err)                                         \
 268                 sv_setnv(var, (double)err) ;                            \
 269                 sv_setpv(var, ((err) ? GetErrorString(err) : "")) ;     \
 270                 SvNOK_on(var);
 271
 272
 273 #if defined(__SYMBIAN32__)
 274 # define NO_WRITEABLE_DATA
 275 #endif
 276
 277 #define TRACE_DEFAULT 0
 278
 279 #ifdef NO_WRITEABLE_DATA
 280 #  define trace TRACE_DEFAULT
 281 #else
 282   static int trace = TRACE_DEFAULT ;
 283 #endif
 284
 285 /* Dodge PerlIO hiding of these functions. */
 286 #undef printf
 287
 288 static char *
 289 #ifdef CAN_PROTOTYPE
 290 GetErrorString(int error_no)
 291 #else
 292 GetErrorString(error_no)
 293 int error_no ;
 294 #endif
 295 {
 296     dTHX;
 297     char * errstr ;
 298
 299     if (error_no == Z_ERRNO) {
 300         errstr = Strerror(errno) ;
 301     }
 302     else
 303         /* errstr = gzerror(fil, &error_no) ; */
 304         errstr = (char*) my_z_errmsg[2 - error_no];
 305
 306     return errstr ;
 307 }
 308
 309
 310 #ifdef MAGIC_APPEND
 311
 312 /*
 313    The following two functions are taken almost directly from
 314    examples/gzappend.c. Only cosmetic changes have been made to conform to
 315    the coding style of the rest of the code in this file.
 316 */
 317
 318
 319 /* return the greatest common divisor of a and b using Euclid's algorithm,
 320    modified to be fast when one argument much greater than the other, and
 321    coded to avoid unnecessary swapping */
 322 static unsigned
 323 #ifdef CAN_PROTOTYPE
 324 gcd(unsigned a, unsigned b)
 325 #else
 326 gcd(a, b)
 327     unsigned a;
 328     unsigned b;
 329 #endif
 330 {
 331     unsigned c;
 332
 333     while (a && b)
 334         if (a > b) {
 335             c = b;
 336             while (a - c >= c)
 337                 c <<= 1;
 338             a -= c;
 339         }
 340         else {
 341             c = a;
 342             while (b - c >= c)
 343                 c <<= 1;
 344             b -= c;
 345         }
 346     return a + b;
 347 }
 348
 349 /* rotate list[0..len-1] left by rot positions, in place */
 350 static void
 351 #ifdef CAN_PROTOTYPE
 352 rotate(unsigned char *list, unsigned len, unsigned rot)
 353 #else
 354 rotate(list, len, rot)
 355     unsigned char *list;
 356     unsigned len ;
 357     unsigned rot;
 358 #endif
 359 {
 360     unsigned char tmp;
 361     unsigned cycles;
 362     unsigned char *start, *last, *to, *from;
 363
 364     /* normalize rot and handle degenerate cases */
 365     if (len < 2) return;
 366     if (rot >= len) rot %= len;
 367     if (rot == 0) return;
 368
 369     /* pointer to last entry in list */
 370     last = list + (len - 1);
 371
 372     /* do simple left shift by one */
 373     if (rot == 1) {
 374         tmp = *list;
 375         memcpy(list, list + 1, len - 1);
 376         *last = tmp;
 377         return;
 378     }
 379
 380     /* do simple right shift by one */
 381     if (rot == len - 1) {
 382         tmp = *last;
 383         memmove(list + 1, list, len - 1);
 384         *list = tmp;
 385         return;
 386     }
 387
 388     /* otherwise do rotate as a set of cycles in place */
 389     cycles = gcd(len, rot);             /* number of cycles */
 390     do {
 391         start = from = list + cycles;   /* start index is arbitrary */
 392         tmp = *from;                    /* save entry to be overwritten */
 393         for (;;) {
 394             to = from;                  /* next step in cycle */
 395             from += rot;                /* go right rot positions */
 396             if (from > last) from -= len;   /* (pointer better not wrap) */
 397             if (from == start) break;   /* all but one shifted */
 398             *to = *from;                /* shift left */
 399         }
 400         *to = tmp;                      /* complete the circle */
 401     } while (--cycles);
 402 }
 403
 404 #endif /* MAGIC_APPEND */
 405
 406 static void
 407 #ifdef CAN_PROTOTYPE
 408 DispHex(void * ptr, int length)
 409 #else
 410 DispHex(ptr, length)
 411     void * ptr;
 412     int length;
 413 #endif
 414 {
 415     char * p = (char*)ptr;
 416     int i;
 417     for (i = 0; i < length; ++i) {
 418         printf(" %02x", 0xFF & *(p+i));
 419     }
 420 }
 421
 422
 423 static void
 424 #ifdef CAN_PROTOTYPE
 425 DispStream(di_stream * s, const char * message)
 426 #else
 427 DispStream(s, message)
 428     di_stream * s;
 429     const char * message;
 430 #endif
 431 {
 432
 433 #if 0
 434     if (! trace)
 435         return ;
 436 #endif
 437
 438 #define EnDis(f) (s->flags & f ? "Enabled" : "Disabled")
 439
 440     printf("DispStream %p", s) ;
 441     if (message)
 442         printf("- %s \n", message) ;
 443     printf("\n") ;
 444
 445     if (!s)  {
 446         printf("    stream pointer is NULL\n");
 447     }
 448     else     {
 449         printf("    stream           %p\n", &(s->stream));
 450         printf("           zalloc    %p\n", s->stream.zalloc);
 451         printf("           zfree     %p\n", s->stream.zfree);
 452         printf("           opaque    %p\n", s->stream.opaque);
 453         printf("           state     %p\n", s->stream.state);
 454         if (s->stream.msg)
 455             printf("           msg       %s\n", s->stream.msg);
 456         else
 457             printf("           msg       \n");
 458         printf("           next_in   %p", s->stream.next_in);
 459         if (s->stream.next_in){
 460             printf(" =>");
 461             DispHex(s->stream.next_in, 4);
 462         }
 463         printf("\n");
 464
 465         printf("           next_out  %p", s->stream.next_out);
 466         if (s->stream.next_out){
 467             printf(" =>");
 468             DispHex(s->stream.next_out, 4);
 469         }
 470         printf("\n");
 471
 472         printf("           avail_in  %lu\n",  (unsigned long)s->stream.avail_in);
 473         printf("           avail_out %lu\n",  (unsigned long)s->stream.avail_out);
 474         printf("           total_in  %ld\n",  s->stream.total_in);
 475         printf("           total_out %ld\n",  s->stream.total_out);
 476         printf("           adler     %ld\n",  s->stream.adler    );
 477         printf("    bufsize          %ld\n",  s->bufsize);
 478         printf("    dictionary       %p\n",   s->dictionary);
 479         printf("    dict_adler       0x%ld\n",s->dict_adler);
 480         printf("    zip_mode         %d\n",   s->zip_mode);
 481         printf("    crc32            0x%x\n", (unsigned)s->crc32);
 482         printf("    adler32          0x%x\n", (unsigned)s->adler32);
 483         printf("    flags            0x%x\n", s->flags);
 484         printf("           APPEND    %s\n",   EnDis(FLAG_APPEND));
 485         printf("           CRC32     %s\n",   EnDis(FLAG_CRC32));
 486         printf("           ADLER32   %s\n",   EnDis(FLAG_ADLER32));
 487         printf("           CONSUME   %s\n",   EnDis(FLAG_CONSUME_INPUT));
 488         printf("           LIMIT     %s\n",   EnDis(FLAG_LIMIT_OUTPUT));
 489
 490
 491 #ifdef MAGIC_APPEND
 492         printf("    window           %p\n", s->window);
 493 #endif
 494         printf("\n");
 495
 496     }
 497 }
 498
 499 #ifdef AT_LEAST_ZLIB_1_2_5_2
 500 voidpf my_zcalloc (voidpf opaque, unsigned items, unsigned size)
 501 {
 502     return safemalloc(items * size);
 503 }
 504
 505
 506 void my_zcfree (voidpf opaque, voidpf ptr)
 507 {
 508     safefree(ptr);
 509     return;
 510 }
 511
 512 #endif
 513
 514 static di_stream *
 515 #ifdef CAN_PROTOTYPE
 516 InitStream(void)
 517 #else
 518 InitStream()
 519 #endif
 520 {
 521     di_stream *s ;
 522
 523     ZMALLOC(s, di_stream) ;
 524
 525 #ifdef AT_LEAST_ZLIB_1_2_5_2
 526     s->stream.zalloc = my_zcalloc;
 527     s->stream.zfree = my_zcfree;
 528 #endif
 529
 530     return s ;
 531 }
 532
 533 static void
 534 #ifdef CAN_PROTOTYPE
 535 PostInitStream(di_stream * s, int flags, int bufsize, int windowBits)
 536 #else
 537 PostInitStream(s, flags, bufsize, windowBits)
 538     di_stream *s ;
 539     int flags ;
 540     int bufsize ;
 541     int windowBits ;
 542 #endif
 543 {
 544     s->bufsize = bufsize ;
 545     s->compressedBytes =
 546     s->uncompressedBytes =
 547     s->last_error = 0 ;
 548     s->flags    = flags ;
 549     s->zip_mode = (windowBits < 0) ;
 550     if (flags & FLAG_CRC32)
 551         s->crc32 = crcInitial ;
 552     if (flags & FLAG_ADLER32)
 553         s->adler32 = adlerInitial ;
 554 }
 555
 556
 557 static SV*
 558 #ifdef CAN_PROTOTYPE
 559 deRef(SV * sv, const char * string)
 560 #else
 561 deRef(sv, string)
 562 SV * sv ;
 563 char * string;
 564 #endif
 565 {
 566     dTHX;
 567     SvGETMAGIC(sv);
 568
 569     if (SvROK(sv)) {
 570         sv = SvRV(sv) ;
 571         SvGETMAGIC(sv);
 572         switch(SvTYPE(sv)) {
 573             case SVt_PVAV:
 574             case SVt_PVHV:
 575             case SVt_PVCV:
 576                 croak("%s: buffer parameter is not a SCALAR reference", string);
 577             default:
 578                 break;
 579         }
 580         if (SvROK(sv))
 581             croak("%s: buffer parameter is a reference to a reference", string) ;
 582     }
 583
 584     if (!SvOK(sv))
 585         sv = sv_2mortal(newSVpv("", 0));
 586
 587     return sv ;
 588 }
 589
 590 static SV*
 591 #ifdef CAN_PROTOTYPE
 592 deRef_l(SV * sv, const char * string)
 593 #else
 594 deRef_l(sv, string)
 595 SV * sv ;
 596 char * string ;
 597 #endif
 598 {
 599     dTHX;
 600     bool wipe = 0 ;
 601     STRLEN na;
 602
 603     SvGETMAGIC(sv);
 604     wipe = ! SvOK(sv) ;
 605
 606     if (SvROK(sv)) {
 607         sv = SvRV(sv) ;
 608         SvGETMAGIC(sv);
 609         wipe = ! SvOK(sv) ;
 610
 611         switch(SvTYPE(sv)) {
 612             case SVt_PVAV:
 613             case SVt_PVHV:
 614             case SVt_PVCV:
 615                 croak("%s: buffer parameter is not a SCALAR reference", string);
 616             default:
 617                 break;
 618         }
 619         if (SvROK(sv))
 620             croak("%s: buffer parameter is a reference to a reference", string) ;
 621     }
 622
 623     if (SvREADONLY(sv) && PL_curcop != &PL_compiling)
 624         croak("%s: buffer parameter is read-only", string);
 625
 626     SvUPGRADE(sv, SVt_PV);
 627
 628     if (wipe)
 629         sv_setpv(sv, "") ;
 630     else
 631         (void)SvPVbyte_force(sv, na) ;
 632
 633     return sv ;
 634 }
 635
 636
 637 #include "constants.h"
 638
 639 MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib        PREFIX = Zip_
 640
 641 REQUIRE:        1.924
 642 PROTOTYPES:     DISABLE
 643
 644 INCLUDE: constants.xs
 645
 646 BOOT:
 647     /* Check this version of zlib is == 1 */
 648     if (zlibVersion()[0] != '1')
 649         croak("Compress::Raw::Zlib needs zlib version 1.x\n") ;
 650
 651     {
 652         /* Create the $os_code scalar */
 653         SV * os_code_sv = perl_get_sv("Compress::Raw::Zlib::gzip_os_code", GV_ADDMULTI) ;
 654         sv_setiv(os_code_sv, GZIP_OS_CODE) ;
 655     }
 656
 657
 658 #define Zip_zlib_version()      (const char*)zlib_version
 659 const char*
 660 Zip_zlib_version()
 661
 662 unsigned
 663 ZLIB_VERNUM()
 664     CODE:
 665 #ifdef ZLIB_VERNUM
 666         RETVAL = ZLIB_VERNUM ;
 667 #else
 668         /* 1.1.4 => 0x1140 */
 669         RETVAL  = (ZLIB_VERSION[0] - '0') << 12 ;
 670         RETVAL += (ZLIB_VERSION[2] - '0') <<  8 ;
 671         RETVAL += (ZLIB_VERSION[4] - '0') <<  4 ;
 672         if (strlen(ZLIB_VERSION) > 5)
 673             RETVAL += (ZLIB_VERSION[6] - '0')  ;
 674 #endif
 675     OUTPUT:
 676         RETVAL
 677
 678
 679 #ifndef AT_LEAST_ZLIB_1_2_1
 680 #define zlibCompileFlags() 0
 681 #endif
 682 uLong
 683 zlibCompileFlags()
 684
 685 MODULE = Compress::Raw::Zlib    PACKAGE = Compress::Raw::Zlib   PREFIX = Zip_
 686
 687 #define Zip_adler32(buf, adler) adler32(adler, buf, (uInt)len)
 688
 689 uLong
 690 Zip_adler32(buf, adler=adlerInitial)
 691         uLong    adler = NO_INIT
 692         STRLEN   len = NO_INIT
 693         Bytef *  buf = NO_INIT
 694         SV *     sv = ST(0) ;
 695         INIT:
 696         /* If the buffer is a reference, dereference it */
 697         sv = deRef(sv, "adler32") ;
 698 #ifdef UTF8_AVAILABLE
 699     if (DO_UTF8(sv) && !sv_utf8_downgrade(sv, 1))
 700          croak("Wide character in Compress::Raw::Zlib::adler32");
 701 #endif
 702         buf = (Byte*)SvPVbyte(sv, len) ;
 703
 704         if (items < 2)
 705           adler = adlerInitial;
 706         else if (SvOK(ST(1)))
 707           adler = SvUV(ST(1)) ;
 708         else
 709           adler = adlerInitial;
 710     OUTPUT:
 711         RETVAL
 712
 713 #define Zip_crc32(buf, crc, offset) crc32(crc, buf+offset, (uInt)len-offset)
 714
 715 uLong
 716 Zip_crc32(buf, crc=crcInitial, offset=0)
 717         uLong    crc = NO_INIT
 718         STRLEN   len = NO_INIT
 719         Bytef *  buf = NO_INIT
 720         int      offset
 721         SV *     sv = ST(0) ;
 722         INIT:
 723         /* If the buffer is a reference, dereference it */
 724         sv = deRef(sv, "crc32") ;
 725 #ifdef UTF8_AVAILABLE
 726     if (DO_UTF8(sv) && !sv_utf8_downgrade(sv, 1))
 727          croak("Wide character in Compress::Raw::Zlib::crc32");
 728 #endif
 729         buf = (Byte*)SvPVbyte(sv, len) ;
 730
 731         if (items < 2)
 732           crc = crcInitial;
 733         else if (SvOK(ST(1)))
 734           crc = SvUV(ST(1)) ;
 735         else
 736           crc = crcInitial;
 737
 738 uLong
 739 crc32_combine(crc1, crc2, len2)
 740         uLong    crc1
 741         uLong    crc2
 742         z_off_t   len2
 743         CODE:
 744 #ifndef AT_LEAST_ZLIB_1_2_2_1
 745         crc1 = crc1; crc2 = crc2 ; len2 = len2; /* Silence -Wall */
 746         croak("crc32_combine needs zlib 1.2.3 or better");
 747 #else
 748         RETVAL = crc32_combine(crc1, crc2, len2);
 749 #endif
 750     OUTPUT:
 751         RETVAL
 752
 753
 754 uLong
 755 adler32_combine(adler1, adler2, len2)
 756         uLong    adler1
 757         uLong    adler2
 758         z_off_t   len2
 759         CODE:
 760 #ifndef AT_LEAST_ZLIB_1_2_2_1
 761         adler1 = adler1; adler2 = adler2 ; len2 = len2; /* Silence -Wall */
 762         croak("adler32_combine needs zlib 1.2.3 or better");
 763 #else
 764         RETVAL = adler32_combine(adler1, adler2, len2);
 765 #endif
 766     OUTPUT:
 767         RETVAL
 768
 769
 770 MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib
 771
 772 void
 773 _deflateInit(flags,level, method, windowBits, memLevel, strategy, bufsize, dictionary)
 774     int flags
 775     int level
 776     int method
 777     int windowBits
 778     int memLevel
 779     int strategy
 780     uLong bufsize
 781     SV* dictionary
 782   PPCODE:
 783     int err ;
 784     deflateStream s ;
 785
 786     if (trace)
 787         warn("in _deflateInit(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%ld dictionary=%p)\n",
 788         level, method, windowBits, memLevel, strategy, bufsize, dictionary) ;
 789     if ((s = InitStream() )) {
 790
 791         s->Level      = level;
 792         s->Method     = method;
 793         s->WindowBits = windowBits;
 794         s->MemLevel   = memLevel;
 795         s->Strategy   = strategy;
 796
 797         err = deflateInit2(&(s->stream), level,
 798                            method, windowBits, memLevel, strategy);
 799
 800         if (trace) {
 801             warn(" _deflateInit2 returned %d (state %p)\n", err, s);
 802             DispStream(s, "INIT");
 803         }
 804
 805         /* Check if a dictionary has been specified */
 806         SvGETMAGIC(dictionary);
 807         if (err == Z_OK && SvPOK(dictionary) && SvCUR(dictionary)) {
 808 #ifdef UTF8_AVAILABLE
 809             if (DO_UTF8(dictionary) && !sv_utf8_downgrade(dictionary, 1))
 810                 croak("Wide character in Compress::Raw::Zlib::Deflate::new dicrionary parameter");
 811 #endif
 812             err = deflateSetDictionary(&(s->stream), (const Bytef*) SvPVX(dictionary), SvCUR(dictionary)) ;
 813         if (trace)
 814             warn("deflateSetDictionary returned %d\n", err);
 815             s->dict_adler = s->stream.adler ;
 816         }
 817
 818         if (err != Z_OK) {
 819             Safefree(s) ;
 820             s = NULL ;
 821         }
 822         else
 823             PostInitStream(s, flags, bufsize, windowBits) ;
 824
 825     }
 826     else
 827         err = Z_MEM_ERROR ;
 828
 829     {
 830         SV* obj = sv_setref_pv(sv_newmortal(),
 831             "Compress::Raw::Zlib::deflateStream", (void*)s);
 832         XPUSHs(obj);
 833     }
 834     if (GIMME == G_ARRAY) {
 835         SV * sv = sv_2mortal(newSViv(err)) ;
 836         setDUALstatus(sv, err);
 837         XPUSHs(sv) ;
 838     }
 839
 840 void
 841 _inflateInit(flags, windowBits, bufsize, dictionary)
 842     int flags
 843     int windowBits
 844     uLong bufsize
 845     SV * dictionary
 846   ALIAS:
 847     _inflateScanInit = 1
 848   PPCODE:
 849
 850     int err = Z_OK ;
 851     inflateStream s ;
 852 #ifndef MAGIC_APPEND
 853     if (ix == 1)
 854         croak("inflateScanInit needs zlib 1.2.1 or better");
 855 #endif
 856     if (trace)
 857         warn("in _inflateInit(windowBits=%d, bufsize=%lu, dictionary=%lu\n",
 858                 windowBits, bufsize, (unsigned long)SvCUR(dictionary)) ;
 859     if ((s = InitStream() )) {
 860
 861         s->WindowBits = windowBits;
 862
 863         err = inflateInit2(&(s->stream), windowBits);
 864         if (err != Z_OK) {
 865             Safefree(s) ;
 866             s = NULL ;
 867         }
 868         else if (sv_len(dictionary)) {
 869 #ifdef AT_LEAST_ZLIB_1_2_2_1
 870         /* Zlib 1.2.2.1 or better allows a dictionary with raw inflate */
 871         if (s->WindowBits < 0) {
 872             STRLEN dlen;
 873             const Bytef* b = (const Bytef*)SvPVbyte(dictionary, dlen);
 874             err = inflateSetDictionary(&(s->stream),
 875                 b, dlen);
 876             if (err != Z_OK) {
 877                 Safefree(s) ;
 878                 s = NULL ;
 879             }
 880         }
 881         else
 882 #endif
 883             /* Dictionary specified - take a copy for use in inflate */
 884             s->dictionary = newSVsv(dictionary) ;
 885         }
 886         if (s) {
 887             PostInitStream(s, flags, bufsize, windowBits) ;
 888 #ifdef MAGIC_APPEND
 889             if (ix == 1)
 890             {
 891                 s->window = (unsigned char *)safemalloc(WINDOW_SIZE);
 892             }
 893 #endif
 894         }
 895     }
 896     else
 897         err = Z_MEM_ERROR ;
 898
 899     {
 900         SV* obj = sv_setref_pv(sv_newmortal(),
 901                    ix == 1
 902                    ? "Compress::Raw::Zlib::inflateScanStream"
 903                    :  "Compress::Raw::Zlib::inflateStream",
 904                    (void*)s);
 905         XPUSHs(obj);
 906     }
 907     if (GIMME == G_ARRAY) {
 908         SV * sv = sv_2mortal(newSViv(err)) ;
 909         setDUALstatus(sv, err);
 910         XPUSHs(sv) ;
 911     }
 912
 913
 914
 915 MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::deflateStream
 916
 917 void
 918 DispStream(s, message=NULL)
 919     Compress::Raw::Zlib::deflateStream   s
 920     const char *  message
 921
 922 DualType
 923 deflateReset(s)
 924     Compress::Raw::Zlib::deflateStream   s
 925   CODE:
 926       RETVAL = deflateReset(&(s->stream)) ;
 927       if (RETVAL == Z_OK) {
 928           PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
 929       }
 930     OUTPUT:
 931       RETVAL
 932
 933 DualType
 934 deflate (s, buf, output)
 935     Compress::Raw::Zlib::deflateStream  s
 936     SV *        buf
 937     SV *        output
 938     uInt        cur_length = NO_INIT
 939     uInt        increment = NO_INIT
 940     uInt        prefix    = NO_INIT
 941     int         RETVAL = 0;
 942     uLong     bufinc = NO_INIT
 943     STRLEN    origlen = NO_INIT
 944   CODE:
 945     bufinc = s->bufsize;
 946
 947     /* If the input buffer is a reference, dereference it */
 948     buf = deRef(buf, "deflate") ;
 949
 950     /* initialise the input buffer */
 951 #ifdef UTF8_AVAILABLE
 952     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
 953          croak("Wide character in Compress::Raw::Zlib::Deflate::deflate input parameter");
 954 #endif
 955     s->stream.next_in = (Bytef*)SvPV_nomg(buf, origlen) ;
 956     s->stream.avail_in = origlen;
 957
 958     if (s->flags & FLAG_CRC32)
 959         s->crc32 = crc32(s->crc32, s->stream.next_in, s->stream.avail_in) ;
 960
 961     if (s->flags & FLAG_ADLER32)
 962         s->adler32 = adler32(s->adler32, s->stream.next_in, s->stream.avail_in) ;
 963
 964     /* and retrieve the output buffer */
 965     output = deRef_l(output, "deflate") ;
 966 #ifdef UTF8_AVAILABLE
 967     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
 968          croak("Wide character in Compress::Raw::Zlib::Deflate::deflate output parameter");
 969 #endif
 970
 971     if((s->flags & FLAG_APPEND) != FLAG_APPEND) {
 972         SvCUR_set(output, 0);
 973         /* sv_setpvn(output, "", 0); */
 974     }
 975     prefix = cur_length =  SvCUR(output) ;
 976     s->stream.next_out = (Bytef*) SvPVX(output) + cur_length;
 977     increment =  SvLEN(output) -  cur_length;
 978     s->stream.avail_out =  increment;
 979 #ifdef SETP_BYTE
 980     /* Check for saved output from deflateParams */
 981     if (s->deflateParams_out_valid) {
 982         *(s->stream.next_out) = s->deflateParams_out_byte;
 983         ++ s->stream.next_out;
 984         -- s->stream.avail_out ;
 985         s->deflateParams_out_valid = FALSE;
 986     }
 987 #else
 988     /* Check for saved output from deflateParams */
 989     if (s->deflateParams_out_length) {
 990         uLong plen = s->deflateParams_out_length ;
 991         /* printf("Copy %d bytes saved data\n", plen);*/
 992         if (s->stream.avail_out < plen) {
 993             /*printf("GROW from %d to %d\n", s->stream.avail_out,
 994                         SvLEN(output) + plen - s->stream.avail_out); */
 995             Sv_Grow(output, SvLEN(output) + plen - s->stream.avail_out) ;
 996         }
 997
 998         Copy(s->stream.next_out, s->deflateParams_out_buffer, plen, Bytef) ;
 999         cur_length = cur_length + plen;
1000         SvCUR_set(output, cur_length);
1001         s->stream.next_out += plen ;
1002         s->stream.avail_out = SvLEN(output) - cur_length ;
1003         increment = s->stream.avail_out;
1004         s->deflateParams_out_length = 0;
1005     }
1006 #endif
1007     RETVAL = Z_OK ;
1008     while (s->stream.avail_in != 0) {
1009
1010         if (s->stream.avail_out == 0) {
1011             /* out of space in the output buffer so make it bigger */
1012             s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc) ;
1013             cur_length += increment ;
1014             s->stream.next_out += cur_length ;
1015             increment = bufinc ;
1016             s->stream.avail_out = increment;
1017             bufinc *= 2 ;
1018         }
1019
1020         if (trace) {
1021           printf("DEFLATE Avail In %d, Out %d\n", s->stream.avail_in, s->stream.avail_out);
1022           DispStream(s, "BEFORE");
1023           /* Perl_sv_dump(output); */
1024         }
1025
1026         RETVAL = deflate(&(s->stream), Z_NO_FLUSH);
1027
1028         if (trace) {
1029             printf("DEFLATE returned %d %s, avail in %d, out %d\n", RETVAL,
1030            GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out);
1031             DispStream(s, "AFTER");
1032         }
1033
1034         if (RETVAL != Z_OK)
1035             break;
1036     }
1037
1038     s->compressedBytes += cur_length + increment - prefix - s->stream.avail_out ;
1039     s->uncompressedBytes  += origlen - s->stream.avail_in  ;
1040
1041     s->last_error = RETVAL ;
1042     if (RETVAL == Z_OK) {
1043         SvPOK_only(output);
1044         SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
1045         SvSETMAGIC(output);
1046     }
1047     OUTPUT:
1048         RETVAL
1049
1050
1051 void
1052 DESTROY(s)
1053     Compress::Raw::Zlib::deflateStream  s
1054   CODE:
1055     if (trace)
1056         printf("Compress::Raw::Zlib::deflateStream::DESTROY %p\n", s);
1057     deflateEnd(&s->stream) ;
1058     if (s->dictionary)
1059         SvREFCNT_dec(s->dictionary) ;
1060 #ifndef SETP_BYTE
1061     if (s->deflateParams_out_buffer)
1062         Safefree(s->deflateParams_out_buffer);
1063 #endif
1064     Safefree(s) ;
1065
1066
1067 DualType
1068 flush(s, output, f=Z_FINISH)
1069     Compress::Raw::Zlib::deflateStream  s
1070     SV * output
1071     int  f
1072     uInt        cur_length = NO_INIT
1073     uInt        increment = NO_INIT
1074     uInt        prefix    = NO_INIT
1075     uLong     bufinc = NO_INIT
1076     uLong     availableout = NO_INIT
1077   CODE:
1078     bufinc = s->bufsize;
1079
1080     s->stream.avail_in = 0; /* should be zero already anyway */
1081
1082     /* retrieve the output buffer */
1083     output = deRef_l(output, "flush") ;
1084 #ifdef UTF8_AVAILABLE
1085     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
1086          croak("Wide character in Compress::Raw::Zlib::Deflate::flush input parameter");
1087 #endif
1088     if(! s->flags & FLAG_APPEND) {
1089         SvCUR_set(output, 0);
1090         /* sv_setpvn(output, "", 0); */
1091     }
1092     prefix = cur_length =  SvCUR(output) ;
1093     s->stream.next_out = (Bytef*) SvPVX(output) + cur_length;
1094     increment =  SvLEN(output) -  cur_length;
1095     s->stream.avail_out =  increment;
1096 #ifdef SETP_BYTE
1097     /* Check for saved output from deflateParams */
1098     if (s->deflateParams_out_valid) {
1099         *(s->stream.next_out) = s->deflateParams_out_byte;
1100         ++ s->stream.next_out;
1101         -- s->stream.avail_out ;
1102         s->deflateParams_out_valid = FALSE;
1103     }
1104 #else
1105     /* Check for saved output from deflateParams */
1106     if (s->deflateParams_out_length) {
1107         uLong plen = s->deflateParams_out_length ;
1108         /* printf("Copy %d bytes saved data\n", plen); */
1109         if (s->stream.avail_out < plen) {
1110             /* printf("GROW from %d to %d\n", s->stream.avail_out,
1111                         SvLEN(output) + plen - s->stream.avail_out); */
1112             Sv_Grow(output, SvLEN(output) + plen - s->stream.avail_out) ;
1113         }
1114
1115         Copy(s->stream.next_out, s->deflateParams_out_buffer, plen, Bytef) ;
1116         cur_length = cur_length + plen;
1117         SvCUR_set(output, cur_length);
1118         s->stream.next_out += plen ;
1119         s->stream.avail_out = SvLEN(output) - cur_length ;
1120         increment = s->stream.avail_out;
1121         s->deflateParams_out_length = 0;
1122     }
1123 #endif
1124
1125     for (;;) {
1126         if (s->stream.avail_out == 0) {
1127             /* consumed all the available output, so extend it */
1128             s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc) ;
1129             cur_length += increment ;
1130             s->stream.next_out += cur_length ;
1131             increment = bufinc ;
1132             s->stream.avail_out = increment;
1133             bufinc *= 2 ;
1134         }
1135
1136         availableout = s->stream.avail_out ;
1137
1138         if (trace) {
1139           printf("flush (%d) DEFLATE Avail In %d, Out %d\n", f, s->stream.avail_in, s->stream.avail_out);
1140           DispStream(s, "BEFORE");
1141           /* Perl_sv_dump(output); */
1142         }
1143
1144         RETVAL = deflate(&(s->stream), f);
1145
1146         if (trace) {
1147             printf("flush DEFLATE returned %d %s, avail in %d, out %d\n", RETVAL,
1148             GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out);
1149             DispStream(s, "AFTER");
1150         }
1151
1152         /* Ignore the second of two consecutive flushes: */
1153         if (availableout == s->stream.avail_out && RETVAL == Z_BUF_ERROR)
1154             RETVAL = Z_OK;
1155
1156         /* deflate has finished flushing only when it hasn't used up
1157          * all the available space in the output buffer:
1158          */
1159         if (s->stream.avail_out != 0 || RETVAL != Z_OK )
1160             break;
1161     }
1162
1163     RETVAL =  (RETVAL == Z_STREAM_END ? Z_OK : RETVAL) ;
1164     s->last_error = RETVAL ;
1165
1166     s->compressedBytes    += cur_length + increment - prefix - s->stream.avail_out ;
1167
1168     if (RETVAL == Z_OK) {
1169         SvPOK_only(output);
1170         SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
1171         SvSETMAGIC(output);
1172     }
1173     OUTPUT:
1174         RETVAL
1175
1176
1177 DualType
1178 _deflateParams(s, flags, level, strategy, bufsize)
1179         Compress::Raw::Zlib::deflateStream      s
1180         int     flags
1181         int     level
1182         int     strategy
1183         uLong   bufsize
1184     CODE:
1185         /* printf("_deflateParams(Flags %d Level %d Strategy %d Bufsize %d)\n", flags, level, strategy, bufsize);
1186         printf("Before -- Level %d, Strategy %d, Bufsize %d\n", s->Level, s->Strategy, s->bufsize); */
1187         if (flags & 1)
1188             s->Level = level ;
1189         if (flags & 2)
1190             s->Strategy = strategy ;
1191         if (flags & 4) {
1192             s->bufsize = bufsize;
1193         }
1194         /* printf("After --  Level %d, Strategy %d, Bufsize %d\n", s->Level, s->Strategy, s->bufsize);*/
1195 #ifdef SETP_BYTE
1196         s->stream.avail_in = 0;
1197         s->stream.next_out = &(s->deflateParams_out_byte) ;
1198         s->stream.avail_out = 1;
1199         RETVAL = deflateParams(&(s->stream), s->Level, s->Strategy);
1200         s->deflateParams_out_valid =
1201                 (RETVAL == Z_OK && s->stream.avail_out == 0) ;
1202         /* printf("RETVAL %d, avail out %d, byte %c\n", RETVAL, s->stream.avail_out, s->deflateParams_out_byte); */
1203 #else
1204         /* printf("Level %d Strategy %d, Prev Len %d\n",
1205                 s->Level, s->Strategy, s->deflateParams_out_length); */
1206         s->stream.avail_in = 0;
1207         if (s->deflateParams_out_buffer == NULL)
1208             s->deflateParams_out_buffer = safemalloc(deflateParams_BUFFER_SIZE);
1209         s->stream.next_out = s->deflateParams_out_buffer ;
1210         s->stream.avail_out = deflateParams_BUFFER_SIZE;
1211
1212         RETVAL = deflateParams(&(s->stream), s->Level, s->Strategy);
1213         s->deflateParams_out_length = deflateParams_BUFFER_SIZE - s->stream.avail_out;
1214         /* printf("RETVAL %d, length out %d, avail %d\n",
1215                     RETVAL, s->deflateParams_out_length, s->stream.avail_out ); */
1216 #endif
1217     OUTPUT:
1218         RETVAL
1219
1220
1221 int
1222 get_Level(s)
1223         Compress::Raw::Zlib::deflateStream   s
1224     CODE:
1225         RETVAL = s->Level ;
1226     OUTPUT:
1227         RETVAL
1228
1229 int
1230 get_Strategy(s)
1231         Compress::Raw::Zlib::deflateStream   s
1232     CODE:
1233         RETVAL = s->Strategy ;
1234     OUTPUT:
1235         RETVAL
1236
1237
1238 uLong
1239 get_Bufsize(s)
1240         Compress::Raw::Zlib::deflateStream   s
1241     CODE:
1242         RETVAL = s->bufsize ;
1243     OUTPUT:
1244         RETVAL
1245
1246
1247 int
1248 status(s)
1249         Compress::Raw::Zlib::deflateStream   s
1250     CODE:
1251         RETVAL = s->last_error ;
1252     OUTPUT:
1253         RETVAL
1254
1255 uLong
1256 crc32(s)
1257         Compress::Raw::Zlib::deflateStream   s
1258     CODE:
1259         RETVAL = s->crc32 ;
1260     OUTPUT:
1261         RETVAL
1262
1263 uLong
1264 dict_adler(s)
1265         Compress::Raw::Zlib::deflateStream   s
1266     CODE:
1267         RETVAL = s->dict_adler ;
1268     OUTPUT:
1269         RETVAL
1270
1271 uLong
1272 adler32(s)
1273         Compress::Raw::Zlib::deflateStream   s
1274     CODE:
1275         RETVAL = s->adler32 ;
1276     OUTPUT:
1277         RETVAL
1278
1279 uLong
1280 compressedBytes(s)
1281     Compress::Raw::Zlib::deflateStream  s
1282     CODE:
1283         RETVAL = s->compressedBytes;
1284   OUTPUT:
1285         RETVAL
1286
1287 uLong
1288 uncompressedBytes(s)
1289     Compress::Raw::Zlib::deflateStream  s
1290     CODE:
1291         RETVAL = s->uncompressedBytes;
1292   OUTPUT:
1293         RETVAL
1294
1295 uLong
1296 total_in(s)
1297         Compress::Raw::Zlib::deflateStream   s
1298     CODE:
1299         RETVAL = s->stream.total_in ;
1300     OUTPUT:
1301         RETVAL
1302
1303 uLong
1304 total_out(s)
1305         Compress::Raw::Zlib::deflateStream   s
1306     CODE:
1307         RETVAL = s->stream.total_out ;
1308     OUTPUT:
1309         RETVAL
1310
1311 char*
1312 msg(s)
1313         Compress::Raw::Zlib::deflateStream   s
1314     CODE:
1315         RETVAL = s->stream.msg;
1316     OUTPUT:
1317         RETVAL
1318
1319 int
1320 deflateTune(s, good_length, max_lazy, nice_length, max_chain)
1321             Compress::Raw::Zlib::deflateStream   s
1322             int good_length
1323             int max_lazy
1324             int nice_length
1325             int max_chain
1326     CODE:
1327 #ifndef AT_LEAST_ZLIB_1_2_2_3
1328         good_length = good_length; max_lazy = max_lazy ; /* Silence -Wall */
1329         nice_length = nice_length; max_chain = max_chain; /* Silence -Wall */
1330         croak("deflateTune needs zlib 1.2.2.3 or better");
1331 #else
1332         RETVAL = deflateTune(&(s->stream), good_length, max_lazy, nice_length, max_chain);
1333 #endif
1334     OUTPUT:
1335         RETVAL
1336
1337
1338 MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::inflateStream
1339
1340 void
1341 DispStream(s, message=NULL)
1342     Compress::Raw::Zlib::inflateStream   s
1343     const char *  message
1344
1345 DualType
1346 inflateReset(s)
1347     Compress::Raw::Zlib::inflateStream   s
1348   CODE:
1349       RETVAL = inflateReset(&(s->stream)) ;
1350       if (RETVAL == Z_OK) {
1351           PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
1352       }
1353     OUTPUT:
1354       RETVAL
1355
1356 DualType
1357 inflate (s, buf, output, eof=FALSE)
1358     Compress::Raw::Zlib::inflateStream  s
1359     SV *        buf
1360     SV *        output
1361     bool        eof
1362     uInt        cur_length = 0;
1363     uInt        prefix_length = 0;
1364     int     increment = 0;
1365     uLong   bufinc = NO_INIT
1366     STRLEN  na = NO_INIT ;
1367   PREINIT:
1368 #ifdef UTF8_AVAILABLE
1369     bool        out_utf8  = FALSE;
1370 #endif
1371     STRLEN      origlen;
1372   CODE:
1373     bufinc = s->bufsize;
1374     /* If the buffer is a reference, dereference it */
1375     buf = deRef(buf, "inflate") ;
1376
1377     if (s->flags & FLAG_CONSUME_INPUT) {
1378         if (SvREADONLY(buf))
1379             croak("Compress::Raw::Zlib::Inflate::inflate input parameter cannot be read-only when ConsumeInput is specified");
1380         SvPV_force(buf, na);
1381     }
1382 #ifdef UTF8_AVAILABLE
1383     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
1384          croak("Wide character in Compress::Raw::Zlib::Inflate::inflate input parameter");
1385 #endif
1386
1387     /* initialise the input buffer */
1388     s->stream.next_in = (Bytef*)SvPV_nomg(buf, origlen) ;
1389     s->stream.avail_in = origlen ;
1390
1391     /* and retrieve the output buffer */
1392     output = deRef_l(output, "inflate") ;
1393 #ifdef UTF8_AVAILABLE
1394     if (DO_UTF8(output))
1395          out_utf8 = TRUE ;
1396     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
1397          croak("Wide character in Compress::Raw::Zlib::Inflate::inflate output parameter");
1398 #endif
1399     if((s->flags & FLAG_APPEND) != FLAG_APPEND) {
1400         SvCUR_set(output, 0);
1401     }
1402
1403     /* Assume no output buffer - the code below will update if there is any available */
1404     s->stream.avail_out = 0;
1405
1406
1407     if (SvLEN(output)) {
1408         prefix_length = cur_length =  SvCUR(output) ;
1409
1410         if (s->flags & FLAG_LIMIT_OUTPUT && SvLEN(output) - cur_length - 1 < bufinc)
1411         {
1412             Sv_Grow(output, bufinc + cur_length + 1) ;
1413         }
1414
1415         /* Only setup the stream output pointers if there is spare
1416            capacity in the outout SV
1417         */
1418         if (SvLEN(output) > cur_length + 1)
1419         {
1420             s->stream.next_out = (Bytef*) SvPV_nomg_nolen(output) + cur_length;
1421             increment = SvLEN(output) -  cur_length - 1;
1422             s->stream.avail_out = increment;
1423         }
1424     }
1425
1426
1427     s->bytesInflated = 0;
1428
1429     RETVAL = Z_OK;
1430
1431     while (RETVAL == Z_OK) {
1432         if (s->stream.avail_out == 0) {
1433             /* out of space in the output buffer so make it bigger */
1434             s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc +1) ;
1435             cur_length += increment ;
1436             s->stream.next_out += cur_length ;
1437             increment = bufinc ;
1438             s->stream.avail_out = increment;
1439             bufinc *= 2 ;
1440         }
1441
1442         /* printf("INFLATE Availl In %d, Out %d\n", s->stream.avail_in,
1443  s->stream.avail_out);
1444 DispStream(s, "BEFORE");
1445 Perl_sv_dump(output); */
1446         RETVAL = inflate(&(s->stream), Z_SYNC_FLUSH);
1447         /* printf("INFLATE returned %d %s, avail in %d, out %d\n", RETVAL,
1448  GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out); */
1449
1450
1451         if (RETVAL == Z_NEED_DICT && s->dictionary) {
1452             STRLEN dlen;
1453             const Bytef* b = (const Bytef*)SvPV(s->dictionary, dlen) ;
1454             s->dict_adler = s->stream.adler ;
1455             RETVAL = inflateSetDictionary(&(s->stream),
1456                 b, dlen);
1457             if (RETVAL == Z_OK)
1458                 continue;
1459         }
1460
1461         if (s->flags & FLAG_LIMIT_OUTPUT &&
1462                 (RETVAL == Z_OK || RETVAL == Z_BUF_ERROR )) {
1463             if (s->stream.avail_out == 0)
1464                 RETVAL = Z_BUF_ERROR;
1465             break;
1466         }
1467         if (s->flags & FLAG_LIMIT_OUTPUT &&
1468                 (RETVAL == Z_OK || RETVAL == Z_BUF_ERROR ))
1469             break;
1470
1471         if (RETVAL == Z_STREAM_ERROR || RETVAL == Z_MEM_ERROR ||
1472             RETVAL == Z_DATA_ERROR   || RETVAL == Z_STREAM_END )
1473             break ;
1474
1475         if (RETVAL == Z_BUF_ERROR) {
1476             if (s->stream.avail_out == 0)
1477                 continue ;
1478             if (s->stream.avail_in == 0) {
1479                 RETVAL = Z_OK ;
1480                 break ;
1481             }
1482         }
1483     }
1484 #ifdef NEED_DUMMY_BYTE_AT_END
1485     if (eof && RETVAL == Z_OK && s->flags & FLAG_LIMIT_OUTPUT == 0) {
1486         Bytef* nextIn =  s->stream.next_in;
1487         uInt availIn =  s->stream.avail_in;
1488         s->stream.next_in = (Bytef*) " ";
1489         s->stream.avail_in = 1;
1490         if (s->stream.avail_out == 0) {
1491             /* out of space in the output buffer so make it bigger */
1492             s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
1493             cur_length += increment ;
1494             s->stream.next_out += cur_length ;
1495             increment = bufinc ;
1496             s->stream.avail_out = increment;
1497             bufinc *= 2 ;
1498         }
1499         RETVAL = inflate(&(s->stream), Z_SYNC_FLUSH);
1500         s->stream.next_in = nextIn ;
1501         s->stream.avail_in  = availIn ;
1502     }
1503 #endif
1504
1505     s->last_error = RETVAL ;
1506     if (RETVAL == Z_OK || RETVAL == Z_STREAM_END || RETVAL == Z_BUF_ERROR || RETVAL == Z_DATA_ERROR) {
1507            unsigned in ;
1508
1509         s->bytesInflated = cur_length + increment - s->stream.avail_out - prefix_length;
1510         s->uncompressedBytes += s->bytesInflated ;
1511         s->compressedBytes   += origlen - s->stream.avail_in  ;
1512
1513         SvPOK_only(output);
1514         SvCUR_set(output, prefix_length + s->bytesInflated) ;
1515         *SvEND(output) = '\0';
1516 #ifdef UTF8_AVAILABLE
1517         if (out_utf8)
1518             sv_utf8_upgrade(output);
1519 #endif
1520         SvSETMAGIC(output);
1521
1522         if (s->flags & FLAG_CRC32 )
1523             s->crc32 = crc32(s->crc32,
1524                                 (const Bytef*)SvPVX(output)+prefix_length,
1525                                 SvCUR(output)-prefix_length) ;
1526
1527         if (s->flags & FLAG_ADLER32)
1528             s->adler32 = adler32(s->adler32,
1529                                 (const Bytef*)SvPVX(output)+prefix_length,
1530                                 SvCUR(output)-prefix_length) ;
1531
1532         /* fix the input buffer */
1533         if (s->flags & FLAG_CONSUME_INPUT || s->flags & FLAG_LIMIT_OUTPUT) {
1534             in = s->stream.avail_in ;
1535             SvCUR_set(buf, in) ;
1536             if (in)
1537                 Move(s->stream.next_in, SvPVX(buf), in, char) ;
1538             *SvEND(buf) = '\0';
1539             SvSETMAGIC(buf);
1540         }
1541
1542     }
1543     OUTPUT:
1544         RETVAL
1545
1546 uLong
1547 inflateCount(s)
1548     Compress::Raw::Zlib::inflateStream  s
1549     CODE:
1550         RETVAL = s->bytesInflated;
1551   OUTPUT:
1552         RETVAL
1553
1554 uLong
1555 compressedBytes(s)
1556     Compress::Raw::Zlib::inflateStream  s
1557     CODE:
1558         RETVAL = s->compressedBytes;
1559   OUTPUT:
1560         RETVAL
1561
1562 uLong
1563 uncompressedBytes(s)
1564     Compress::Raw::Zlib::inflateStream  s
1565     CODE:
1566         RETVAL = s->uncompressedBytes;
1567   OUTPUT:
1568         RETVAL
1569
1570
1571 DualType
1572 inflateSync (s, buf)
1573     Compress::Raw::Zlib::inflateStream  s
1574     SV *        buf
1575   CODE:
1576
1577     /* If the buffer is a reference, dereference it */
1578     buf = deRef(buf, "inflateSync") ;
1579 #ifdef UTF8_AVAILABLE
1580     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
1581          croak("Wide character in Compress::Raw::Zlib::Inflate::inflateSync");
1582 #endif
1583
1584     /* initialise the input buffer */
1585     s->stream.next_in = (Bytef*)SvPV_force_nomg_nolen(buf) ;
1586     s->stream.avail_in = SvCUR(buf) ;
1587
1588     /* inflateSync doesn't create any output */
1589     s->stream.next_out = (Bytef*) NULL;
1590     s->stream.avail_out = 0;
1591
1592     RETVAL = inflateSync(&(s->stream));
1593     s->last_error = RETVAL ;
1594
1595     /* fix the input buffer */
1596     {
1597         unsigned in = s->stream.avail_in ;
1598         SvCUR_set(buf, in) ;
1599         if (in)
1600             Move(s->stream.next_in, SvPVX(buf), in, char) ;
1601         *SvEND(buf) = '\0';
1602         SvSETMAGIC(buf);
1603     }
1604     OUTPUT:
1605         RETVAL
1606
1607 void
1608 DESTROY(s)
1609     Compress::Raw::Zlib::inflateStream  s
1610   CODE:
1611     inflateEnd(&s->stream) ;
1612     if (s->dictionary)
1613         SvREFCNT_dec(s->dictionary) ;
1614 #ifndef SETP_BYTE
1615     if (s->deflateParams_out_buffer)
1616         Safefree(s->deflateParams_out_buffer);
1617 #endif
1618 #ifdef MAGIC_APPEND
1619     if (s->window)
1620         Safefree(s->window);
1621 #endif
1622     Safefree(s) ;
1623
1624
1625 uLong
1626 status(s)
1627         Compress::Raw::Zlib::inflateStream   s
1628     CODE:
1629         RETVAL = s->last_error ;
1630     OUTPUT:
1631         RETVAL
1632
1633 uLong
1634 crc32(s)
1635         Compress::Raw::Zlib::inflateStream   s
1636     CODE:
1637         RETVAL = s->crc32 ;
1638     OUTPUT:
1639         RETVAL
1640
1641 uLong
1642 dict_adler(s)
1643         Compress::Raw::Zlib::inflateStream   s
1644     CODE:
1645         RETVAL = s->dict_adler ;
1646     OUTPUT:
1647         RETVAL
1648
1649 uLong
1650 total_in(s)
1651         Compress::Raw::Zlib::inflateStream   s
1652     CODE:
1653         RETVAL = s->stream.total_in ;
1654     OUTPUT:
1655         RETVAL
1656
1657 uLong
1658 adler32(s)
1659         Compress::Raw::Zlib::inflateStream   s
1660     CODE:
1661         RETVAL = s->adler32 ;
1662     OUTPUT:
1663         RETVAL
1664
1665 uLong
1666 total_out(s)
1667         Compress::Raw::Zlib::inflateStream   s
1668     CODE:
1669         RETVAL = s->stream.total_out ;
1670     OUTPUT:
1671         RETVAL
1672
1673 char*
1674 msg(s)
1675         Compress::Raw::Zlib::inflateStream   s
1676     CODE:
1677         RETVAL = s->stream.msg;
1678     OUTPUT:
1679         RETVAL
1680
1681
1682 uLong
1683 get_Bufsize(s)
1684         Compress::Raw::Zlib::inflateStream   s
1685     CODE:
1686         RETVAL = s->bufsize ;
1687     OUTPUT:
1688         RETVAL
1689
1690 bool
1691 set_Append(s, mode)
1692         Compress::Raw::Zlib::inflateStream   s
1693         bool    mode
1694     CODE:
1695         RETVAL = ((s->flags & FLAG_APPEND) == FLAG_APPEND);
1696         if (mode)
1697             s->flags |= FLAG_APPEND ;
1698         else
1699             s->flags &= ~FLAG_APPEND ;
1700     OUTPUT:
1701         RETVAL
1702
1703 MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::inflateScanStream
1704
1705 void
1706 DESTROY(s)
1707     Compress::Raw::Zlib::inflateScanStream      s
1708   CODE:
1709     inflateEnd(&s->stream) ;
1710     if (s->dictionary)
1711         SvREFCNT_dec(s->dictionary) ;
1712 #ifndef SETP_BYTE
1713     if (s->deflateParams_out_buffer)
1714         Safefree(s->deflateParams_out_buffer);
1715 #endif
1716 #ifdef MAGIC_APPEND
1717     if (s->window)
1718         Safefree(s->window);
1719 #endif
1720     Safefree(s) ;
1721
1722 void
1723 DispStream(s, message=NULL)
1724     Compress::Raw::Zlib::inflateScanStream   s
1725     const char *  message
1726
1727 DualType
1728 inflateReset(s)
1729     Compress::Raw::Zlib::inflateScanStream   s
1730   CODE:
1731       RETVAL = inflateReset(&(s->stream)) ;
1732       if (RETVAL == Z_OK) {
1733           PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
1734       }
1735     OUTPUT:
1736       RETVAL
1737
1738 DualType
1739 scan(s, buf, out=NULL, eof=FALSE)
1740     Compress::Raw::Zlib::inflateScanStream      s
1741     SV *        buf
1742     SV *        out
1743     bool        eof
1744     bool        eof_mode = FALSE;
1745     int    start_len = NO_INIT
1746   CODE:
1747     /* If the input buffer is a reference, dereference it */
1748 #ifndef MAGIC_APPEND
1749         buf = buf;
1750         croak("scan needs zlib 1.2.1 or better");
1751 #else
1752     buf = deRef(buf, "inflateScan") ;
1753 #ifdef UTF8_AVAILABLE
1754     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
1755         croak("Wide character in Compress::Raw::Zlib::InflateScan::scan input parameter");
1756 #endif
1757     /* initialise the input buffer */
1758     s->stream.next_in = (Bytef*)SvPV_nomg_nolen(buf) ;
1759     s->stream.avail_in = SvCUR(buf) ;
1760     start_len = s->stream.avail_in ;
1761     s->bytesInflated = 0 ;
1762     do
1763     {
1764         if (s->stream.avail_in == 0) {
1765             RETVAL = Z_OK ;
1766             break ;
1767         }
1768
1769         /* set up output to next available section of sliding window */
1770         s->stream.avail_out = WINDOW_SIZE - s->window_have;
1771         s->stream.next_out = s->window + s->window_have;
1772
1773         /* DispStream(s, "before inflate\n"); */
1774
1775         /* inflate and check for errors */
1776         RETVAL = inflate(&(s->stream), Z_BLOCK);
1777
1778         if (start_len > 1 && ! eof_mode)
1779             s->window_lastByte = *(s->stream.next_in - 1 ) ;
1780
1781         if (RETVAL == Z_STREAM_ERROR || RETVAL == Z_MEM_ERROR ||
1782             RETVAL == Z_DATA_ERROR )
1783             break ;
1784
1785         if (s->flags & FLAG_CRC32 )
1786             s->crc32 = crc32(s->crc32, s->window + s->window_have,
1787                              WINDOW_SIZE - s->window_have - s->stream.avail_out);
1788
1789         if (s->flags & FLAG_ADLER32)
1790             s->adler32 = adler32(s->adler32, s->window + s->window_have,
1791                                  WINDOW_SIZE - s->window_have - s->stream.avail_out);
1792
1793         s->uncompressedBytes =
1794         s->bytesInflated += WINDOW_SIZE - s->window_have - s->stream.avail_out;
1795
1796         if (s->stream.avail_out)
1797             s->window_have = WINDOW_SIZE - s->stream.avail_out;
1798         else {
1799             s->window_have = 0;
1800             s->window_full = 1;
1801         }
1802
1803         /* process end of block */
1804         if (s->stream.data_type & 128) {
1805             if (s->stream.data_type & 64) {
1806                 s->window_left = s->stream.data_type & 0x1f;
1807             }
1808             else {
1809                 s->window_lastbit = s->stream.data_type & 0x1f;
1810                 s->lastBlockOffset = s->stream.total_in;
1811             }
1812         }
1813
1814     } while (RETVAL != Z_STREAM_END);
1815
1816     s->last_error = RETVAL ;
1817     s->window_lastoff = s->stream.total_in ;
1818     s->compressedBytes += SvCUR(buf) - s->stream.avail_in  ;
1819
1820     if (RETVAL == Z_STREAM_END)
1821     {
1822         s->matchedEndBlock = 1 ;
1823
1824         /* save the location of the end of the compressed data */
1825         s->window_end = SvCUR(buf) - s->stream.avail_in - 1 ;
1826         s->window_endOffset = s->stream.total_in ;
1827         if (s->window_left)
1828         {
1829             -- s->window_endOffset ;
1830         }
1831
1832         /* if window wrapped, build dictionary from window by rotating */
1833         if (s->window_full) {
1834             rotate(s->window, WINDOW_SIZE, s->window_have);
1835             s->window_have = WINDOW_SIZE;
1836         }
1837
1838         /* if (s->flags & FLAG_CONSUME_INPUT) { */
1839         if (1) {
1840             unsigned in = s->stream.avail_in ;
1841             SvCUR_set(buf, in) ;
1842             if (in)
1843                 Move(s->stream.next_in, SvPVX(buf), in, char) ;
1844                 *SvEND(buf) = '\0';
1845                 SvSETMAGIC(buf);
1846         }
1847     }
1848 #endif
1849   OUTPUT:
1850         RETVAL
1851
1852
1853 uLong
1854 getEndOffset(s)
1855     Compress::Raw::Zlib::inflateScanStream      s
1856     CODE:
1857 #ifndef MAGIC_APPEND
1858         croak("getEndOffset needs zlib 1.2.1 or better");
1859 #else
1860         RETVAL = s->window_endOffset;
1861 #endif
1862   OUTPUT:
1863         RETVAL
1864
1865 uLong
1866 inflateCount(s)
1867     Compress::Raw::Zlib::inflateScanStream      s
1868     CODE:
1869 #ifndef MAGIC_APPEND
1870         croak("inflateCount needs zlib 1.2.1 or better");
1871 #else
1872         RETVAL = s->bytesInflated;
1873 #endif
1874   OUTPUT:
1875         RETVAL
1876
1877 uLong
1878 compressedBytes(s)
1879     Compress::Raw::Zlib::inflateScanStream      s
1880     CODE:
1881         RETVAL = s->compressedBytes;
1882   OUTPUT:
1883         RETVAL
1884
1885 uLong
1886 uncompressedBytes(s)
1887     Compress::Raw::Zlib::inflateScanStream      s
1888     CODE:
1889         RETVAL = s->uncompressedBytes;
1890   OUTPUT:
1891         RETVAL
1892
1893
1894 uLong
1895 getLastBlockOffset(s)
1896     Compress::Raw::Zlib::inflateScanStream      s
1897     CODE:
1898 #ifndef MAGIC_APPEND
1899         croak("getLastBlockOffset needs zlib 1.2.1 or better");
1900 #else
1901         RETVAL = s->lastBlockOffset - (s->window_lastbit != 0);
1902 #endif
1903   OUTPUT:
1904         RETVAL
1905
1906 uLong
1907 getLastBufferOffset(s)
1908     Compress::Raw::Zlib::inflateScanStream      s
1909     CODE:
1910 #ifndef MAGIC_APPEND
1911         croak("getLastBufferOffset needs zlib 1.2.1 or better");
1912 #else
1913         RETVAL = s->window_lastoff;
1914 #endif
1915   OUTPUT:
1916         RETVAL
1917
1918 void
1919 resetLastBlockByte(s, byte)
1920     Compress::Raw::Zlib::inflateScanStream      s
1921     unsigned char*                      byte
1922     CODE:
1923 #ifndef MAGIC_APPEND
1924         croak("resetLastBlockByte needs zlib 1.2.1 or better");
1925 #else
1926         if (byte != NULL)
1927             *byte = *byte ^ (1 << ((8 - s->window_lastbit) & 7));
1928 #endif
1929
1930
1931 void
1932 _createDeflateStream(inf_s, flags,level, method, windowBits, memLevel, strategy, bufsize)
1933     Compress::Raw::Zlib::inflateScanStream      inf_s
1934     int flags
1935     int level
1936     int method
1937     int windowBits
1938     int memLevel
1939     int strategy
1940     uLong bufsize
1941   PPCODE:
1942   {
1943 #ifndef MAGIC_APPEND
1944         flags = flags;
1945         level = level ;
1946         method = method;
1947         windowBits = windowBits;
1948         memLevel = memLevel;
1949         strategy = strategy;
1950         bufsize= bufsize;
1951         croak("_createDeflateStream needs zlib 1.2.1 or better");
1952 #else
1953     int err ;
1954     deflateStream s ;
1955
1956     if (trace)
1957         warn("in _createDeflateStream(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%lu\n",
1958         level, method, windowBits, memLevel, strategy, bufsize) ;
1959     if ((s = InitStream() )) {
1960
1961         s->Level      = level;
1962         s->Method     = method;
1963         s->WindowBits = windowBits;
1964         s->MemLevel   = memLevel;
1965         s->Strategy   = strategy;
1966
1967         err = deflateInit2(&(s->stream), level,
1968                            method, windowBits, memLevel, strategy);
1969
1970         if (err == Z_OK) {
1971             err = deflateSetDictionary(&(s->stream), inf_s->window, inf_s->window_have);
1972             s->dict_adler = s->stream.adler ;
1973         }
1974
1975         if (err != Z_OK) {
1976             Safefree(s) ;
1977             s = NULL ;
1978         }
1979         else {
1980             PostInitStream(s, flags, bufsize, windowBits) ;
1981             s->crc32            = inf_s->crc32;
1982             s->adler32          = inf_s->adler32;
1983             s->stream.adler     = inf_s->stream.adler ;
1984             /* s->stream.total_out = inf_s->bytesInflated ; */
1985             s->stream.total_in  = inf_s->stream.total_out ;
1986             if (inf_s->window_left) {
1987                 /* printf("** window_left %d, window_lastByte %d\n", inf_s->window_left, inf_s->window_lastByte); */
1988                 deflatePrime(&(s->stream), 8 - inf_s->window_left, inf_s->window_lastByte);
1989             }
1990         }
1991     }
1992     else
1993         err = Z_MEM_ERROR ;
1994
1995     XPUSHs(sv_setref_pv(sv_newmortal(),
1996             "Compress::Raw::Zlib::deflateStream", (void*)s));
1997     if (GIMME == G_ARRAY) {
1998         SV * sv = sv_2mortal(newSViv(err)) ;
1999         setDUALstatus(sv, err);
2000         XPUSHs(sv) ;
2001     }
2002 #endif
2003   }
2004
2005 DualType
2006 status(s)
2007         Compress::Raw::Zlib::inflateScanStream   s
2008     CODE:
2009         RETVAL = s->last_error ;
2010     OUTPUT:
2011         RETVAL
2012
2013 uLong
2014 crc32(s)
2015         Compress::Raw::Zlib::inflateScanStream   s
2016     CODE:
2017         RETVAL = s->crc32 ;
2018     OUTPUT:
2019         RETVAL
2020
2021
2022 uLong
2023 adler32(s)
2024         Compress::Raw::Zlib::inflateScanStream   s
2025     CODE:
2026         RETVAL = s->adler32 ;
2027     OUTPUT:
2028         RETVAL
2029