hwpfilter/source/hgzip.cpp

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: hgzip.cpp,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompile.h"
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include <errno.h>
  37 #include "hgzip.h"
  38 #include "hstream.h"
  39
  40 #ifndef local
  41 #  define local static
  42 #endif
  43
  44 #define Z_BUFSIZE   (1024 * 4)
  45
  46 #define ALLOC(size) malloc(size)
  47 #define TRYFREE(p) {if (p) free(p);}
  48
  49 #define ASCII_FLAG   0x01                         /* bit 0 set: file probably ascii text */
  50 #define HEAD_CRC     0x02                         /* bit 1 set: header CRC present */
  51 #define EXTRA_FIELD  0x04                         /* bit 2 set: extra field present */
  52 #define ORIG_NAME    0x08                         /* bit 3 set: original file name present */
  53 #define COMMENT      0x10                         /* bit 4 set: file comment present */
  54 #define RESERVED     0xE0                         /* bits 5..7: reserved */
  55
  56 local int get_byte(gz_stream * s);
  57 local int destroy(gz_stream * s);
  58 local uLong getLong(gz_stream * s);
  59
  60 /* ===========================================================================
  61    Opens a gzip (.gz) file for reading or writing. The mode parameter
  62    is as in fopen ("rb" or "wb"). The file is given either by file descriptor
  63    or path name (if fd == -1).
  64      gz_open return NULL if the file could not be opened or if there was
  65    insufficient memory to allocate the (de)compression state; errno
  66    can be checked to distinguish the two cases (if errno is zero, the
  67    zlib error is Z_MEM_ERROR).
  68 */
  69 gz_stream *gz_open(HStream & _stream)
  70 {
  71     int err;
  72     //int level = Z_DEFAULT_COMPRESSION;            /* compression level */
  73
  74 //  char        *p = (char*)mode;
  75     //char fmode[80];                               /* copy of mode, without the compression level */
  76     //char *m = fmode;
  77     gz_stream *s;
  78
  79     s = (gz_stream *) ALLOC(sizeof(gz_stream));
  80     if (!s)
  81         return Z_NULL;
  82     s->stream.zalloc = (alloc_func) 0;
  83     s->stream.zfree = (free_func) 0;
  84     s->stream.opaque = (voidpf) 0;
  85     s->stream.next_in = s->inbuf = Z_NULL;
  86     s->stream.next_out = s->outbuf = Z_NULL;
  87     s->stream.avail_in = s->stream.avail_out = 0;
  88 //s->_inputstream = NULL;
  89     s->z_err = Z_OK;
  90     s->z_eof = 0;
  91     s->crc = crc32(0L, Z_NULL, 0);
  92     s->msg = NULL;
  93     s->transparent = 0;
  94
  95     s->mode = 'r';
  96
  97 //realking
  98     err = inflateInit2(&(s->stream), -MAX_WBITS);
  99     s->stream.next_in = s->inbuf = (Byte *) ALLOC(Z_BUFSIZE);
 100
 101     if (err != Z_OK || s->inbuf == Z_NULL)
 102     {
 103         return destroy(s), (gz_stream *) Z_NULL;
 104     }
 105
 106     s->stream.avail_out = Z_BUFSIZE;
 107
 108     errno = 0;
 109     s->_inputstream = &_stream;
 110
 111     return (gz_stream *) s;
 112 }
 113
 114
 115 /* ===========================================================================
 116      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
 117    for end of file.
 118    IN assertion: the stream s has been sucessfully opened for reading.
 119 */
 120 local int get_byte(gz_stream * s)
 121 {
 122     if (s->z_eof)
 123         return EOF;
 124     if (s->stream.avail_in == 0)
 125     {
 126         errno = 0;
 127
 128         s->stream.avail_in = s->_inputstream->readBytes(s->inbuf, Z_BUFSIZE);
 129         if (s->stream.avail_in == 0)
 130         {
 131             s->z_eof = 1;
 132             return EOF;
 133         }
 134         s->stream.next_in = s->inbuf;
 135     }
 136     s->stream.avail_in--;
 137     return *(s->stream.next_in)++;
 138 }
 139
 140
 141 /* ===========================================================================
 142  * Cleanup then free the given gz_stream. Return a zlib error code.
 143  * Try freeing in the reverse order of allocations.
 144  */
 145 local int destroy(gz_stream * s)
 146 {
 147     int err = Z_OK;
 148
 149     if (!s)
 150         return Z_STREAM_ERROR;
 151
 152     TRYFREE(s->msg);
 153
 154     if (s->stream.state != NULL)
 155     {
 156         err = inflateEnd(&(s->stream));
 157     }
 158     if (s->z_err < 0)
 159         err = s->z_err;
 160
 161     TRYFREE(s->inbuf);
 162     TRYFREE(s->outbuf);
 163     TRYFREE(s);
 164     return err;
 165 }
 166
 167
 168 // typedef unsigned char  Byte
 169 // typedef Byte  FAR Bytef;
 170 /* ===========================================================================
 171    Reads the given number of uncompressed bytes from the compressed file.
 172    gz_read returns the number of bytes actually read (0 for end of file).
 173 */
 174 int gz_read(gz_stream * file, voidp buf, unsigned len)
 175 {
 176 //printf("@@ gz_read : len : %d\t",len);
 177     gz_stream *s = (gz_stream *) file;
 178     Bytef *start = (Bytef *) buf;                 /* starting point for crc computation */
 179     Byte *next_out;                               /* == stream.next_out but not forced far (for MSDOS) */
 180     if (s == NULL)
 181         return Z_STREAM_ERROR;
 182
 183     if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)
 184         return -1;
 185     if (s->z_err == Z_STREAM_END)
 186         return 0;                                 /* EOF */
 187
 188     s->stream.next_out = next_out = (Bytef *) buf;
 189     s->stream.avail_out = len;
 190
 191     while (s->stream.avail_out != 0)
 192     {
 193         if (s->transparent)
 194         {
 195 /* Copy first the lookahead bytes: */
 196             uInt n = s->stream.avail_in;
 197
 198             if (n > s->stream.avail_out)
 199                 n = s->stream.avail_out;
 200             if (n > 0)
 201             {
 202                 memcpy(s->stream.next_out, s->stream.next_in, n);
 203                 next_out += n;
 204                 s->stream.next_out = next_out;
 205                 s->stream.next_in += n;
 206                 s->stream.avail_out -= n;
 207                 s->stream.avail_in -= n;
 208             }
 209             if (s->stream.avail_out > 0)
 210             {
 211                 s->stream.avail_out -=
 212                     s->_inputstream->readBytes(next_out, s->stream.avail_out);
 213             }
 214             return (int) (len - s->stream.avail_out);
 215         }
 216         if (s->stream.avail_in == 0 && !s->z_eof)
 217         {
 218
 219             errno = 0;
 220             s->stream.avail_in = s->_inputstream->readBytes(s->inbuf, Z_BUFSIZE);
 221             if (s->stream.avail_in == 0)
 222             {
 223                 s->z_eof = 1;
 224                 break;
 225             }
 226             s->stream.next_in = s->inbuf;
 227         }
 228         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
 229
 230         if (s->z_err == Z_STREAM_END)
 231         {
 232 /* Check CRC and original size */
 233             s->crc = crc32(s->crc, start, (uInt) (s->stream.next_out - start));
 234             start = s->stream.next_out;
 235
 236             if (getLong(s) != s->crc || getLong(s) != s->stream.total_out)
 237             {
 238                 s->z_err = Z_DATA_ERROR;
 239             }
 240             else if (s->z_err == Z_OK)
 241             {
 242                 inflateReset(&(s->stream));
 243                 s->crc = crc32(0L, Z_NULL, 0);
 244             }
 245         }
 246         if (s->z_err != Z_OK || s->z_eof)
 247             break;
 248     }
 249     s->crc = crc32(s->crc, start, (uInt) (s->stream.next_out - start));
 250     return (int) (len - s->stream.avail_out);
 251 }
 252
 253 /* ===========================================================================
 254      Flushes all pending output into the compressed file. The parameter
 255    flush is as in the deflate() function.
 256      gz_flush should be called only when strictly necessary because it can
 257    degrade compression.
 258 */
 259 int gz_flush(gz_stream * file, int flush)
 260 {
 261     uInt len;
 262     int done = 0;
 263     gz_stream *s = (gz_stream *) file;
 264
 265     if (s == NULL || s->mode != 'w')
 266         return Z_STREAM_ERROR;
 267
 268     s->stream.avail_in = 0;                       /* should be zero already anyway */
 269
 270     for (;;)
 271     {
 272         len = Z_BUFSIZE - s->stream.avail_out;
 273         if (len != 0)
 274         {
 275 /*
 276       if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
 277     s->z_err = Z_ERRNO;
 278     return Z_ERRNO;
 279       }
 280       */
 281             s->stream.next_out = s->outbuf;
 282             s->stream.avail_out = Z_BUFSIZE;
 283         }
 284         if (done)
 285             break;
 286         s->z_err = deflate(&(s->stream), flush);
 287
 288 /* deflate has finished flushing only when it hasn't used up
 289  * all the available space in the output buffer:
 290  */
 291         done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
 292
 293         if (s->z_err != Z_OK && s->z_err != Z_STREAM_END)
 294             break;
 295     }
 296     return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 297 }
 298
 299
 300 /* ===========================================================================
 301    Reads a long in LSB order from the given gz_stream. Sets
 302 */
 303 local uLong getLong(gz_stream * s)
 304 {
 305     uLong x = (uLong) get_byte(s);
 306     int c;
 307
 308     x += ((uLong) get_byte(s)) << 8;
 309     x += ((uLong) get_byte(s)) << 16;
 310     c = get_byte(s);
 311     if (c == EOF)
 312         s->z_err = Z_DATA_ERROR;
 313     x += ((uLong) c) << 24;
 314     return x;
 315 }
 316
 317
 318 /* ===========================================================================
 319    Flushes all pending output if necessary, closes the compressed file
 320    and deallocates all the (de)compression state.
 321 */
 322 int gz_close(gz_stream * file)
 323 {
 324 //  int err;
 325     gz_stream *s = (gz_stream *) file;
 326
 327     if (s == NULL)
 328         return Z_STREAM_ERROR;
 329 #if 0
 330     if (s->mode == 'w')
 331     {
 332         err = gz_flush(file, Z_FINISH);
 333         if (err != Z_OK)
 334             return destroy(s);
 335         putLong(s->file, s->crc);
 336         putLong(s->file, s->stream.total_in);
 337     }
 338 #endif
 339     return destroy(s);
 340 }