src/encoding/bzip2.c

   1 /* Bzip2 encoding (ENCODING_BZIP2) 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_BZLIB_H
  13 #include <bzlib.h> /* Everything needs this after stdio.h */
  14 #endif
  15 #include <errno.h>
  16
  17 #include "elinks.h"
  18
  19 #include "encoding/bzip2.h"
  20 #include "encoding/encoding.h"
  21 #include "util/memory.h"
  22
  23 #define ELINKS_BZ_BUFFER_LENGTH BZ_MAX_UNUSED
  24
  25 struct bz2_enc_data {
  26         bz_stream fbz_stream;
  27         int fdread;
  28         int last_read; /* If err after last bzDecompress was BZ_STREAM_END.. */
  29         unsigned char buf[ELINKS_BZ_BUFFER_LENGTH]; /* must be the last */
  30 };
  31
  32 static int
  33 bzip2_open(struct stream_encoded *stream, int fd)
  34 {
  35         struct bz2_enc_data *data = mem_alloc(sizeof(*data));
  36         int err;
  37
  38         stream->data = 0;
  39         if (!data) {
  40                 return -1;
  41         }
  42         memset(data, 0, sizeof(struct bz2_enc_data) - ELINKS_BZ_BUFFER_LENGTH);
  43
  44         data->last_read = 0;
  45         data->fdread = fd;
  46
  47         err = BZ2_bzDecompressInit(&data->fbz_stream, 0, 0);
  48         if (err != BZ_OK) {
  49                 mem_free(data);
  50                 return -1;
  51         }
  52
  53         stream->data = data;
  54
  55         return 0;
  56 }
  57
  58 static int
  59 bzip2_read(struct stream_encoded *stream, unsigned char *buf, int len)
  60 {
  61         struct bz2_enc_data *data = (struct bz2_enc_data *) stream->data;
  62         int err = 0;
  63
  64         if (!data) return -1;
  65
  66         assert(len > 0);
  67
  68         if (data->last_read) return 0;
  69
  70         data->fbz_stream.avail_out = len;
  71         data->fbz_stream.next_out = buf;
  72
  73         do {
  74                 if (data->fbz_stream.avail_in == 0) {
  75                         int l = safe_read(data->fdread, data->buf,
  76                                           ELINKS_BZ_BUFFER_LENGTH);
  77
  78                         if (l == -1) {
  79                                 if (errno == EAGAIN)
  80                                         break;
  81                                 else
  82                                         return -1; /* I/O error */
  83                         } else if (l == 0) {
  84                                 /* EOF. It is error: we wait for more bytes */
  85                                 return -1;
  86                         }
  87
  88                         data->fbz_stream.next_in = data->buf;
  89                         data->fbz_stream.avail_in = l;
  90                 }
  91
  92                 err = BZ2_bzDecompress(&data->fbz_stream);
  93                 if (err == BZ_STREAM_END) {
  94                         data->last_read = 1;
  95                         break;
  96                 } else if (err != BZ_OK) {
  97                         return -1;
  98                 }
  99         } while (data->fbz_stream.avail_out > 0);
 100
 101         return len - data->fbz_stream.avail_out;
 102 }
 103
 104 static unsigned char *
 105 bzip2_decode(struct stream_encoded *stream, unsigned char *data, int len,
 106              int *new_len)
 107 {
 108         *new_len = len;
 109         return data;
 110 }
 111
 112 #ifdef CONFIG_SMALL
 113 #define BZIP2_SMALL 1
 114 #else
 115 #define BZIP2_SMALL 0
 116 #endif
 117
 118 static unsigned char *
 119 bzip2_decode_buffer(unsigned char *data, int len, int *new_len)
 120 {
 121         bz_stream stream;
 122         unsigned char *buffer = NULL;
 123         int error;
 124
 125         memset(&stream, 0, sizeof(bz_stream));
 126         stream.next_in = data;
 127         stream.avail_in = len;
 128
 129         if (BZ2_bzDecompressInit(&stream, 0, BZIP2_SMALL) != BZ_OK)
 130                 return NULL;
 131
 132         do {
 133                 unsigned char *new_buffer;
 134                 size_t size = stream.total_out_lo32 + MAX_STR_LEN;
 135
 136                 /* FIXME: support for 64 bit.  real size is
 137                  *
 138                  *      (total_in_hi32 << * 32) + total_in_lo32
 139                  *
 140                  * --jonas */
 141                 assertm(!stream.total_out_hi32, "64 bzip2 decoding not supported");
 142
 143                 new_buffer = mem_realloc(buffer, size);
 144                 if (!new_buffer) {
 145                         error = BZ_MEM_ERROR;
 146                         break;
 147                 }
 148
 149                 buffer           = new_buffer;
 150                 stream.next_out  = buffer + stream.total_out_lo32;
 151                 stream.avail_out = MAX_STR_LEN;
 152
 153                 error = BZ2_bzDecompress(&stream);
 154                 if (error == BZ_STREAM_END) {
 155                         *new_len = stream.total_out_lo32;
 156                         error = BZ_OK;
 157                         break;
 158                 }
 159
 160                 /* Apparently BZ_STREAM_END is not forced when the end of input
 161                  * is reached. At least lindi- reported that it caused a
 162                  * reproducable infinite loop. Maybe it has to do with decoding
 163                  * an incomplete file. */
 164         } while (error == BZ_OK && stream.avail_in > 0);
 165
 166         BZ2_bzDecompressEnd(&stream);
 167
 168         if (error != BZ_OK) {
 169                 if (buffer) mem_free(buffer);
 170                 *new_len = 0;
 171                 return NULL;
 172         }
 173
 174         return buffer;
 175 }
 176
 177 static void
 178 bzip2_close(struct stream_encoded *stream)
 179 {
 180         struct bz2_enc_data *data = (struct bz2_enc_data *) stream->data;
 181
 182         if (data) {
 183                 BZ2_bzDecompressEnd(&data->fbz_stream);
 184                 close(data->fdread);
 185                 mem_free(data);
 186                 stream->data = 0;
 187         }
 188 }
 189
 190 static unsigned char *bzip2_extensions[] = { ".bz2", ".tbz", NULL };
 191
 192 struct decoding_backend bzip2_decoding_backend = {
 193         "bzip2",
 194         bzip2_extensions,
 195         bzip2_open,
 196         bzip2_read,
 197         bzip2_decode,
 198         bzip2_decode_buffer,
 199         bzip2_close,
 200 };