ail/zlib.cpp

   1 #include <iostream>
   2 #include <zlib.h>
   3 #include <ail/zlib.hpp>
   4
   5 namespace ail
   6 {
   7         namespace
   8         {
   9                 std::size_t const buffer_size = 16 * 1024;
  10                 int gzip_window_bits = 16 + MAX_WBITS;
  11         }
  12
  13         std::string get_zlib_error_string(int error)
  14         {
  15                 switch(error)
  16                 {
  17                         case Z_BUF_ERROR:
  18                                 return "zlib: Buffer error";
  19
  20                         case Z_MEM_ERROR:
  21                                 return "zlib: Insufficient memory";
  22
  23                         case Z_STREAM_ERROR:
  24                                 return "zlib: Stream error";
  25
  26                         case Z_NEED_DICT:
  27                                 return "zlib: Need dictionary";
  28
  29                         case Z_DATA_ERROR:
  30                                 return "zlib: Invalid input";
  31
  32                         default:
  33                                 return "zlib: Unknown inflation error occured";
  34                 }
  35         }
  36
  37         void deflate_data(char const * input, std::size_t size, bool is_gzip, std::string & output)
  38         {
  39                 char buffer[buffer_size];
  40
  41                 z_stream stream;
  42
  43                 stream.next_in = reinterpret_cast<Bytef *>(const_cast<char *>(input));
  44                 stream.avail_in = static_cast<uInt>(size);
  45                 stream.next_out = reinterpret_cast<Bytef *>(buffer);
  46                 stream.avail_out = static_cast<uInt>(sizeof(buffer));
  47                 stream.zalloc = Z_NULL;
  48                 stream.zfree = Z_NULL;
  49                 stream.opaque = Z_NULL;
  50
  51                 int result;
  52                 if(is_gzip)
  53                         result = ::deflateInit2(&stream, Z_BEST_COMPRESSION, Z_DEFLATED, gzip_window_bits, 8, Z_DEFAULT_STRATEGY);
  54                 else
  55                         result = ::deflateInit(&stream, Z_BEST_COMPRESSION);
  56
  57                 if(result != Z_OK)
  58                         throw exception("zlib: Deflate initialisation error");
  59
  60                 while(true)
  61                 {
  62                         stream.next_out = reinterpret_cast<Bytef *>(buffer);
  63                         stream.avail_out = static_cast<uInt>(sizeof(buffer));
  64
  65                         int result = ::deflate(&stream, Z_SYNC_FLUSH);
  66                         if(result == Z_OK)
  67                                 output.append(buffer, static_cast<uInt>(sizeof(buffer)) - stream.avail_out);
  68                         else
  69                         {
  70                                 ::deflateEnd(&stream);
  71                                 throw exception(get_zlib_error_string(result));
  72                         }
  73
  74                         if(stream.total_in == size)
  75                                 break;
  76                 }
  77
  78                 ::deflateEnd(&stream);
  79         }
  80
  81         void inflate_data(char const * input, std::size_t size, bool is_gzip, std::string & output)
  82         {
  83                 char buffer[buffer_size];
  84
  85                 z_stream stream;
  86
  87                 stream.next_in = reinterpret_cast<Bytef *>(const_cast<char *>(input));
  88                 stream.avail_in = static_cast<uInt>(size);
  89                 stream.next_out = reinterpret_cast<Bytef *>(buffer);
  90                 stream.avail_out = static_cast<uInt>(sizeof(buffer));
  91                 stream.zalloc = Z_NULL;
  92                 stream.zfree = Z_NULL;
  93                 stream.opaque = Z_NULL;
  94
  95                 int result;
  96
  97                 if(is_gzip)
  98                         result = ::inflateInit2(&stream, gzip_window_bits);
  99                 else
 100                         result = ::inflateInit(&stream);
 101
 102                 if(result != Z_OK)
 103                         throw exception("zlib: Inflate initialisation error");
 104
 105                 while(true)
 106                 {
 107                         stream.next_out = reinterpret_cast<Bytef *>(buffer);
 108                         stream.avail_out = static_cast<uInt>(sizeof(buffer));
 109
 110                         int result = ::inflate(&stream, Z_SYNC_FLUSH);
 111                         switch(result)
 112                         {
 113                                 case Z_OK:
 114                                 case Z_STREAM_END:
 115                                         output.append(buffer, static_cast<uInt>(sizeof(buffer)) - stream.avail_out);
 116                                         break;
 117
 118                                 default:
 119                                         ::inflateEnd(&stream);
 120                                         throw exception(get_zlib_error_string(result));
 121                         }
 122
 123                         if(stream.total_in == size)
 124                                 break;
 125                 }
 126
 127                 ::inflateEnd(&stream);
 128         }
 129
 130         void deflate(char const * input, std::size_t size, std::string & output)
 131         {
 132                 deflate_data(input, size, false, output);
 133         }
 134
 135         void compress_gzip(char const * input, std::size_t size, std::string & output)
 136         {
 137                 deflate_data(input, size, true, output);
 138         }
 139
 140         void deflate(std::string const & input, std::string & output)
 141         {
 142                 deflate(input.c_str(), input.size(), output);
 143         }
 144
 145         void compress_gzip(std::string const & input, std::string & output)
 146         {
 147                 compress_gzip(input.c_str(), input.size(), output);
 148         }
 149
 150         void inflate(char const * input, std::size_t size, std::string & output)
 151         {
 152                 inflate_data(input, size, false, output);
 153         }
 154
 155         void decompress_gzip(char const * input, std::size_t size, std::string & output)
 156         {
 157                 inflate_data(input, size, true, output);
 158         }
 159
 160         void inflate(std::string const & input, std::string & output)
 161         {
 162                 inflate(input.c_str(), input.size(), output);
 163         }
 164
 165         void decompress_gzip(std::string const & input, std::string & output)
 166         {
 167                 decompress_gzip(input.c_str(), input.size(), output);
 168         }
 169 }