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