src/encoding/deflate.c

   1 /* deflate/gzip encoding backend */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #ifdef HAVE_UNISTD_H
  10 #include <unistd.h>
  11 #endif
  12 #ifdef HAVE_ZLIB_H
  13 #include <zlib.h>
  14 #endif
  15 #include <errno.h>
  16
  17 #include "elinks.h"
  18
  19 #include "encoding/deflate.h"
  20 #include "encoding/encoding.h"
  21 #include "util/memory.h"
  22
  23 /* How many bytes of compressed data to read before decompressing. */
  24 #define ELINKS_DEFLATE_BUFFER_LENGTH 5000
  25
  26 struct deflate_enc_data {
  27         z_stream deflate_stream;
  28
  29         /* The file descriptor from which we read.  */
  30         int fdread;
  31
  32         unsigned int last_read:1;
  33         unsigned int after_first_read:1;
  34
  35         /* A buffer for data that has been read from the file but not
  36          * yet decompressed.  z_stream.next_in and z_stream.avail_in
  37          * refer to this buffer.  */
  38         unsigned char buf[ELINKS_DEFLATE_BUFFER_LENGTH];
  39 };
  40
  41 static int
  42 deflate_open(int window_size, struct stream_encoded *stream, int fd)
  43 {
  44         /* A zero-initialized z_stream.  The compiler ensures that all
  45          * pointer members in it are null.  (Can't do this with memset
  46          * because C99 does not require all-bits-zero to be a null
  47          * pointer.)  */
  48         static const z_stream null_z_stream = {0};
  49         int err;
  50
  51         struct deflate_enc_data *data = mem_alloc(sizeof(*data));
  52
  53         stream->data = NULL;
  54         if (!data) {
  55                 return -1;
  56         }
  57
  58         /* Initialize all members of *data, except data->buf[], which
  59          * will be initialized on demand by deflate_read.  */
  60         copy_struct(&data->deflate_stream, &null_z_stream);
  61         data->fdread = fd;
  62         data->last_read = 0;
  63         data->after_first_read = 0;
  64
  65         err = inflateInit2(&data->deflate_stream, window_size);
  66         if (err != Z_OK) {
  67                 mem_free(data);
  68                 return -1;
  69         }
  70         stream->data = data;
  71
  72         return 0;
  73 }
  74
  75 #if 0
  76 static int
  77 deflate_raw_open(struct stream_encoded *stream, int fd)
  78 {
  79         /* raw DEFLATE with neither zlib nor gzip header */
  80         return deflate_open(-MAX_WBITS, stream, fd);
  81 }
  82 #endif
  83
  84 static int
  85 deflate_gzip_open(struct stream_encoded *stream, int fd)
  86 {
  87         /* detect gzip header, else assume zlib header */
  88         return deflate_open(MAX_WBITS + 32, stream, fd);
  89 }
  90
  91 static int
  92 deflate_read(struct stream_encoded *stream, unsigned char *buf, int len)
  93 {
  94         struct deflate_enc_data *data = (struct deflate_enc_data *) stream->data;
  95         int err = 0;
  96         int l = 0;
  97
  98         if (!data) return -1;
  99
 100         assert(len > 0);
 101
 102         if (data->last_read) return 0;
 103
 104         data->deflate_stream.avail_out = len;
 105         data->deflate_stream.next_out = buf;
 106
 107         do {
 108                 if (data->deflate_stream.avail_in == 0) {
 109                         l = safe_read(data->fdread, data->buf,
 110                                           ELINKS_DEFLATE_BUFFER_LENGTH);
 111
 112                         if (l == -1) {
 113                                 if (errno == EAGAIN)
 114                                         break;
 115                                 else
 116                                         return -1; /* I/O error */
 117                         } else if (l == 0) {
 118                                 /* EOF. It is error: we wait for more bytes */
 119                                 return -1;
 120                         }
 121
 122                         data->deflate_stream.next_in = data->buf;
 123                         data->deflate_stream.avail_in = l;
 124                 }
 125 restart:
 126                 err = inflate(&data->deflate_stream, Z_SYNC_FLUSH);
 127                 if (err == Z_DATA_ERROR && !data->after_first_read) {
 128                         data->after_first_read = 1;
 129                         inflateEnd(&data->deflate_stream);
 130                         data->deflate_stream.avail_out = len;
 131                         data->deflate_stream.next_out = buf;
 132                         data->deflate_stream.next_in = data->buf;
 133                         data->deflate_stream.avail_in = l;
 134                         err = inflateInit2(&data->deflate_stream, -MAX_WBITS);
 135                         if (err == Z_OK) goto restart;
 136                 }
 137                 data->after_first_read = 1;
 138                 if (err == Z_STREAM_END) {
 139                         data->last_read = 1;
 140                         break;
 141                 } else if (err != Z_OK) {
 142                         return -1;
 143                 }
 144         } while (data->deflate_stream.avail_out > 0);
 145
 146         assert(len - data->deflate_stream.avail_out == data->deflate_stream.next_out - buf);
 147         return len - data->deflate_stream.avail_out;
 148 }
 149
 150 static unsigned char *
 151 deflate_decode_buffer(int window_size, unsigned char *data, int len, int *new_len)
 152 {
 153         z_stream stream;
 154         unsigned char *buffer = NULL;
 155         int error;
 156
 157         *new_len = 0;     /* default, left there if an error occurs */
 158
 159         if (!len) return NULL;
 160         memset(&stream, 0, sizeof(z_stream));
 161         stream.next_in = data;
 162         stream.avail_in = len;
 163
 164         if (inflateInit2(&stream, window_size) != Z_OK)
 165                 return NULL;
 166
 167         do {
 168                 unsigned char *new_buffer;
 169                 size_t size = stream.total_out + MAX_STR_LEN;
 170
 171                 new_buffer = mem_realloc(buffer, size);
 172                 if (!new_buffer) {
 173                         error = Z_MEM_ERROR;
 174                         break;
 175                 }
 176
 177                 buffer           = new_buffer;
 178                 stream.next_out  = buffer + stream.total_out;
 179                 stream.avail_out = MAX_STR_LEN;
 180
 181                 error = inflate(&stream, Z_SYNC_FLUSH);
 182                 if (error == Z_STREAM_END) {
 183                         error = Z_OK;
 184                         break;
 185                 }
 186         } while (error == Z_OK && stream.avail_in > 0);
 187
 188         inflateEnd(&stream);
 189
 190         if (error == Z_OK) {
 191                 *new_len = stream.total_out;
 192                 return buffer;
 193         } else {
 194                 if (buffer) mem_free(buffer);
 195                 return NULL;
 196         }
 197 }
 198
 199 static unsigned char *
 200 deflate_raw_decode_buffer(unsigned char *data, int len, int *new_len)
 201 {
 202         /* raw DEFLATE with neither zlib nor gzip header */
 203         return deflate_decode_buffer(-MAX_WBITS, data, len, new_len);
 204 }
 205
 206 static unsigned char *
 207 deflate_gzip_decode_buffer(unsigned char *data, int len, int *new_len)
 208 {
 209         /* detect gzip header, else assume zlib header */
 210         return deflate_decode_buffer(MAX_WBITS + 32, data, len, new_len);
 211 }
 212
 213 static void
 214 deflate_close(struct stream_encoded *stream)
 215 {
 216         struct deflate_enc_data *data = (struct deflate_enc_data *) stream->data;
 217
 218         if (data) {
 219                 inflateEnd(&data->deflate_stream);
 220                 close(data->fdread);
 221                 mem_free(data);
 222                 stream->data = 0;
 223         }
 224 }
 225
 226 static const unsigned char *const deflate_extensions[] = { NULL };
 227
 228 const struct decoding_backend deflate_decoding_backend = {
 229         "deflate",
 230         deflate_extensions,
 231         deflate_gzip_open,
 232         deflate_read,
 233         deflate_raw_decode_buffer,
 234         deflate_close,
 235 };
 236
 237 static const unsigned char *const gzip_extensions[] = { ".gz", ".tgz", NULL };
 238
 239 const struct decoding_backend gzip_decoding_backend = {
 240         "gzip",
 241         gzip_extensions,
 242         deflate_gzip_open,
 243         deflate_read,
 244         deflate_gzip_decode_buffer,
 245         deflate_close,
 246 };