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