libbase/zlib_adapter.cpp

   1 // zlib_adapter.cpp    -- Thatcher Ulrich 2003
   2
   3 // This source code has been donated to the Public Domain.  Do
   4 // whatever you want with it.
   5
   6 // Code to wrap zlib compression/decompression around a IOChannel
   7 // stream.
   8
   9
  10 #include "zlib_adapter.h"
  11 #include "IOChannel.h" // for inheritance
  12 #include "log.h"
  13 #include "GnashException.h"
  14 #include <algorithm> // std::min
  15
  16 #include <sstream>
  17 #include <memory>
  18
  19 namespace gnash {
  20
  21
  22 #ifndef HAVE_ZLIB_H
  23
  24
  25 // Stubs, in case client doesn't want to link to zlib.
  26 namespace zlib_adapter
  27 {
  28     std::auto_ptr<IOChannel> make_inflater(std::auto_ptr<IOChannel> /*in*/)
  29     {
  30         abort(); // callers should check this themselves
  31         return std::auto_ptr<IOChannel>(NULL);
  32     }
  33
  34     IOChannel* make_deflater(IOChannel* /*out*/)
  35     {
  36         abort(); // callers should check this themselves
  37         return NULL;
  38     }
  39 }
  40
  41
  42 #else // HAVE_ZLIB_H
  43
  44 extern "C" {
  45 #include <zlib.h>
  46 }
  47
  48 namespace zlib_adapter
  49 {
  50
  51 class InflaterIOChannel : public IOChannel
  52 {
  53 public:
  54
  55     /// Constructor.
  56     InflaterIOChannel(std::auto_ptr<IOChannel> in);
  57
  58     ~InflaterIOChannel() {
  59         rewind_unused_bytes();
  60         inflateEnd(&(m_zstream));
  61     }
  62
  63     // See dox in IOChannel
  64     virtual bool seek(std::streampos pos);
  65
  66     // See dox in IOChannel
  67     virtual std::streamsize read(void* dst, std::streamsize bytes)
  68     {
  69         if (m_error) return 0;
  70         return inflate_from_stream(dst, bytes);
  71     }
  72
  73     // See dox in IOChannel
  74     virtual void go_to_end();
  75
  76     // See dox in IOChannel
  77     virtual std::streampos tell() const
  78     {
  79         return m_logical_stream_pos;
  80     }
  81
  82     // See dox in IOChannel
  83     virtual bool eof() const
  84     {
  85         return m_at_eof;
  86     }
  87
  88     // See dox in IOChannel
  89     virtual bool bad() const
  90     {
  91         return m_error;
  92     }
  93
  94 private:
  95
  96     static const int ZBUF_SIZE = 4096;
  97
  98     std::auto_ptr<IOChannel> m_in;
  99
 100     // position of the input stream where we started inflating.
 101     std::streampos m_initial_stream_pos;
 102
 103     unsigned char m_rawdata[ZBUF_SIZE];
 104
 105     z_stream m_zstream;
 106
 107     // current stream position of uncompressed data.
 108     std::streampos m_logical_stream_pos;
 109
 110     bool m_at_eof;
 111     bool m_error;
 112
 113     /// Discard current results and rewind to the beginning.
 114     //
 115     //
 116     /// Necessary in order to seek backwards.
 117     ///
 118     /// might throw a ParserException if unable to reset the uderlying
 119     /// stream to original position.
 120     ///
 121     void reset();
 122
 123     std::streamsize inflate_from_stream(void* dst, std::streamsize bytes);
 124
 125     // If we have unused bytes in our input buffer, rewind
 126     // to before they started.
 127     void rewind_unused_bytes();
 128
 129 };
 130
 131 const int InflaterIOChannel::ZBUF_SIZE;
 132
 133 void
 134 InflaterIOChannel::rewind_unused_bytes()
 135 {
 136     if (m_zstream.avail_in > 0)
 137     {
 138         int    pos = m_in->tell();
 139         int    rewound_pos = pos - m_zstream.avail_in;
 140         assert(pos >= 0);
 141         assert(pos >= m_initial_stream_pos);
 142         assert(rewound_pos >= 0);
 143         assert(rewound_pos >= m_initial_stream_pos);
 144
 145         m_in->seek(rewound_pos);
 146     }
 147 }
 148
 149 void
 150 InflaterIOChannel::reset()
 151 {
 152     m_error = 0;
 153     m_at_eof = 0;
 154     int    err = inflateReset(&m_zstream);
 155     if (err != Z_OK) {
 156         log_error("inflater_impl::reset() inflateReset() returned %d", err);
 157         m_error = 1;
 158         return;
 159     }
 160
 161     m_zstream.next_in = 0;
 162     m_zstream.avail_in = 0;
 163
 164     m_zstream.next_out = 0;
 165     m_zstream.avail_out = 0;
 166
 167     // Rewind the underlying stream.
 168     if (!m_in->seek(m_initial_stream_pos))
 169     {
 170         std::stringstream ss;
 171         ss << "inflater_impl::reset: unable to seek underlying "
 172             "stream to position " <<  m_initial_stream_pos;
 173         throw ParserException(ss.str());
 174     }
 175
 176     m_logical_stream_pos = m_initial_stream_pos;
 177 }
 178
 179 std::streamsize
 180 InflaterIOChannel::inflate_from_stream(void* dst, std::streamsize bytes)
 181 {
 182
 183     assert(bytes);
 184
 185     if (m_error) return 0;
 186
 187     m_zstream.next_out = static_cast<unsigned char*>(dst);
 188     m_zstream.avail_out = bytes;
 189
 190     for (;;)
 191     {
 192         if (m_zstream.avail_in == 0)
 193         {
 194             // Get more raw data.
 195             int    new_bytes = m_in->read(m_rawdata, ZBUF_SIZE);
 196             if (new_bytes == 0)
 197             {
 198                 // The cupboard is bare!  We have nothing to feed to inflate().
 199                 break;
 200             }
 201             else
 202             {
 203                 m_zstream.next_in = m_rawdata;
 204                 m_zstream.avail_in = new_bytes;
 205             }
 206         }
 207
 208         int    err = inflate(&m_zstream, Z_SYNC_FLUSH);
 209         if (err == Z_STREAM_END)
 210         {
 211             m_at_eof = true;
 212             break;
 213         }
 214         if (err == Z_BUF_ERROR)
 215         {
 216             std::ostringstream ss;
 217             ss << __FILE__ << ":" << __LINE__ << ": " << m_zstream.msg;
 218             log_error("%s", ss.str());
 219             break;
 220         }
 221         if (err == Z_DATA_ERROR)
 222         {
 223             std::ostringstream ss;
 224             ss << __FILE__ << ":" << __LINE__ << ": " << m_zstream.msg;
 225             throw ParserException(ss.str());
 226             break;
 227         }
 228         if (err == Z_MEM_ERROR)
 229         {
 230             std::ostringstream ss;
 231             ss << __FILE__ << ":" << __LINE__ << ": " << m_zstream.msg;
 232             throw ParserException(ss.str());
 233             break;
 234         }
 235         if (err != Z_OK)
 236         {
 237             // something's wrong.
 238             std::ostringstream ss;
 239             ss << __FILE__ << ":" << __LINE__ << ": " << m_zstream.msg;
 240             throw ParserException(ss.str());
 241             //m_error = 1;
 242             break;
 243         }
 244
 245         if (m_zstream.avail_out == 0)
 246         {
 247             break;
 248         }
 249     }
 250
 251     if (m_error)
 252     {
 253         return 0;
 254     }
 255
 256     int    bytes_read = bytes - m_zstream.avail_out;
 257     m_logical_stream_pos += bytes_read;
 258
 259     return bytes_read;
 260 }
 261
 262 void
 263 InflaterIOChannel::go_to_end()
 264 {
 265     if (m_error)
 266     {
 267         throw IOException("InflaterIOChannel is in error condition, can't seek to end");
 268     }
 269
 270     // Keep reading until we can't read any more.
 271
 272     unsigned char    temp[ZBUF_SIZE];
 273
 274     // Seek forwards.
 275     for (;;)
 276     {
 277         std::streamsize bytes_read = inflate_from_stream(temp, ZBUF_SIZE);
 278         if (bytes_read == 0)
 279         {
 280             // We've seeked as far as we can.
 281             break;
 282         }
 283     }
 284 }
 285
 286 bool
 287 InflaterIOChannel::seek(std::streampos pos)
 288 {
 289     if (m_error)
 290     {
 291         log_debug("Inflater is in error condition");
 292         return false;
 293     }
 294
 295     // If we're seeking backwards, then restart from the beginning.
 296     if (pos < m_logical_stream_pos)
 297     {
 298         log_debug("inflater reset due to seek back from %d to %d",
 299                 m_logical_stream_pos, pos );
 300         reset();
 301     }
 302
 303     unsigned char temp[ZBUF_SIZE];
 304
 305     // Now seek forwards, by just reading data in blocks.
 306     while (m_logical_stream_pos < pos)
 307     {
 308         std::streamsize to_read = pos - m_logical_stream_pos;
 309         assert(to_read > 0);
 310
 311         std::streamsize readNow = std::min<std::streamsize>(to_read, ZBUF_SIZE);
 312         assert(readNow > 0);
 313
 314         std::streamsize bytes_read = inflate_from_stream(temp, readNow);
 315         assert(bytes_read <= readNow);
 316         if (bytes_read == 0)
 317         {
 318             // Trouble; can't seek any further.
 319             log_debug("Trouble: can't seek any further.. ");
 320             return false;
 321             break;
 322         }
 323     }
 324
 325     assert(m_logical_stream_pos == pos);
 326
 327     return true;
 328 }
 329
 330 InflaterIOChannel::InflaterIOChannel(std::auto_ptr<IOChannel> in)
 331     :
 332     m_in(in),
 333     m_initial_stream_pos(m_in->tell()),
 334     m_logical_stream_pos(m_initial_stream_pos),
 335     m_at_eof(false),
 336     m_error(0)
 337 {
 338     assert(m_in.get());
 339
 340     m_zstream.zalloc = (alloc_func)0;
 341     m_zstream.zfree = (free_func)0;
 342     m_zstream.opaque = (voidpf)0;
 343
 344     m_zstream.next_in  = 0;
 345     m_zstream.avail_in = 0;
 346
 347     m_zstream.next_out = 0;
 348     m_zstream.avail_out = 0;
 349
 350     int    err = inflateInit(&m_zstream);
 351     if (err != Z_OK) {
 352         log_error("inflater_impl::ctor() inflateInit() returned %d", err);
 353         m_error = 1;
 354         return;
 355     }
 356
 357     // Ready to go!
 358 }
 359
 360
 361
 362 std::auto_ptr<IOChannel> make_inflater(std::auto_ptr<IOChannel> in)
 363 {
 364     assert(in.get());
 365     return std::auto_ptr<IOChannel> (new InflaterIOChannel(in));
 366 }
 367
 368
 369 // @@ TODO
 370 // IOChannel*    make_deflater(IOChannel* out) { ... }
 371
 372 }
 373
 374 #endif // HAVE_ZLIB_H
 375
 376 } // namespace gnash
 377
 378 // Local Variables:
 379 // mode: C++
 380 // c-basic-offset: 8
 381 // tab-width: 8
 382 // indent-tabs-mode: t
 383 // End: