src/encoding/brotli.c

   1 /* Brotli encoding (ENCODING_BROTLI) 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
  13 #include <brotli/decode.h>
  14 #include <errno.h>
  15
  16 #include "elinks.h"
  17
  18 #include "encoding/brotli.h"
  19 #include "encoding/encoding.h"
  20 #include "util/math.h"
  21 #include "util/memory.h"
  22
  23 #define ELINKS_BROTLI_BUFFER_LENGTH 4096
  24
  25 struct br_enc_data {
  26         BrotliDecoderState *state;
  27
  28         const uint8_t *next_in;
  29         uint8_t *next_out;
  30
  31         size_t avail_in;
  32         size_t avail_out;
  33         size_t total_out;
  34
  35         /* The file descriptor from which we read.  */
  36         int fdread;
  37         int after_end:1;
  38         int last_read:1;
  39         unsigned char buf[ELINKS_BROTLI_BUFFER_LENGTH];
  40 };
  41
  42 static int
  43 brotli_open(struct stream_encoded *stream, int fd)
  44 {
  45         struct br_enc_data *data = mem_calloc(1, sizeof(*data));
  46
  47         stream->data = NULL;
  48         if (!data) {
  49                 return -1;
  50         }
  51         data->state = BrotliDecoderCreateInstance(NULL, NULL, NULL);
  52
  53         if (!data->state) {
  54                 mem_free(data);
  55                 return -1;
  56         }
  57
  58         data->fdread = fd;
  59         stream->data = data;
  60
  61         return 0;
  62 }
  63
  64 static int
  65 brotli_read(struct stream_encoded *stream, unsigned char *buf, int len)
  66 {
  67         struct br_enc_data *data = (struct br_enc_data *) stream->data;
  68         int err = 0;
  69
  70         if (!data) return -1;
  71
  72         assert(len > 0);
  73
  74         if (data->last_read) return 0;
  75
  76         data->avail_out = len;
  77         data->next_out = buf;
  78
  79         do {
  80                 if (data->avail_in == 0) {
  81                         int l = safe_read(data->fdread, data->buf,
  82                                           ELINKS_BROTLI_BUFFER_LENGTH);
  83
  84                         if (l == -1) {
  85                                 if (errno == EAGAIN)
  86                                         break;
  87                                 else
  88                                         return -1; /* I/O error */
  89                         } else if (l == 0) {
  90                                 /* EOF. It is error: we wait for more bytes */
  91                                 return -1;
  92                         }
  93
  94                         data->next_in = data->buf;
  95                         data->avail_in = l;
  96                 }
  97
  98                 err = BrotliDecoderDecompressStream(data->state, &data->avail_in, &data->next_in,
  99                 &data->avail_out, &data->next_out, &data->total_out);
 100
 101                 if (err == BROTLI_DECODER_RESULT_SUCCESS) {
 102                         data->last_read = 1;
 103                         break;
 104                 } else if (err == BROTLI_DECODER_RESULT_ERROR) {
 105                         return -1;
 106                 }
 107         } while (data->avail_out > 0);
 108
 109         assert(len - data->avail_out == data->next_out - buf);
 110         return len - data->avail_out;
 111 }
 112
 113 static unsigned char *
 114 brotli_decode_buffer(struct stream_encoded *st, unsigned char *data, int len, int *new_len)
 115 {
 116         struct br_enc_data *enc_data = (struct br_enc_data *)st->data;
 117         BrotliDecoderState *state = enc_data->state;
 118         unsigned char *buffer = NULL;
 119         int error;
 120
 121         *new_len = 0;     /* default, left there if an error occurs */
 122
 123         if (!len) return NULL;
 124
 125         enc_data->next_in = data;
 126         enc_data->avail_in = len;
 127         enc_data->total_out = 0;
 128
 129         do {
 130                 unsigned char *new_buffer;
 131                 size_t size = enc_data->total_out + ELINKS_BROTLI_BUFFER_LENGTH;
 132
 133                 new_buffer = mem_realloc(buffer, size);
 134
 135                 if (!new_buffer) {
 136                         error = BROTLI_DECODER_RESULT_ERROR;
 137                         break;
 138                 }
 139
 140                 buffer           = new_buffer;
 141                 enc_data->next_out  = buffer + enc_data->total_out;
 142                 enc_data->avail_out = ELINKS_BROTLI_BUFFER_LENGTH;
 143
 144                 error = BrotliDecoderDecompressStream(state, &enc_data->avail_in, &enc_data->next_in,
 145                 &enc_data->avail_out, &enc_data->next_out, &enc_data->total_out);
 146
 147                 if (error == BROTLI_DECODER_RESULT_SUCCESS) {
 148                         *new_len = enc_data->total_out;
 149                         enc_data->after_end = 1;
 150                         return buffer;
 151                 }
 152
 153         } while (error == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
 154
 155         mem_free_if(buffer);
 156         return NULL;
 157 }
 158
 159 static void
 160 brotli_close(struct stream_encoded *stream)
 161 {
 162         struct br_enc_data *data = (struct br_enc_data *) stream->data;
 163
 164         if (data) {
 165                 if (data->state) BrotliDecoderDestroyInstance(data->state);
 166                 if (data->fdread != -1) {
 167                         close(data->fdread);
 168                 }
 169                 mem_free(data);
 170                 stream->data = 0;
 171         }
 172 }
 173
 174 static const unsigned char *const brotli_extensions[] = { ".br", NULL };
 175
 176 const struct decoding_backend brotli_decoding_backend = {
 177         "brotli",
 178         brotli_extensions,
 179         brotli_open,
 180         brotli_read,
 181         brotli_decode_buffer,
 182         brotli_close,
 183 };