decode.c

Go to the documentation of this file.

/*
 * File: decode.c
 *
 * Copyright 2007-2008 Jorge Arellano Cid <jcid@dillo.org>
 * Copyright 2025 Rodrigo Arias Mallo <rodarima@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 */
 
#include "config.h"
 
#include <zlib.h>
#include <iconv.h>
#include <errno.h>
#include <stdlib.h>     /* strtol */
 
#ifdef ENABLE_BROTLI
#include <brotli/decode.h>
#endif
 
#include "decode.h"
#include "utf8.hh"
#include "msg.h"
 
static const int bufsize = 8*1024;
 
Dstr *a_Decode_transfer_process(DecodeTransfer *dc, const char *instr,
                                int inlen)
{
   char *inputPtr, *eol;
   int inputRemaining;
   int chunkRemaining = *((int *)dc->state);
   Dstr *output = dStr_sized_new(inlen);
 
   dStr_append_l(dc->leftover, instr, inlen);
   inputPtr = dc->leftover->str;
   inputRemaining = dc->leftover->len;
 
   while (inputRemaining > 0) {
      if (chunkRemaining > 2) {
         /* chunk body to copy */
         int copylen = MIN(chunkRemaining - 2, inputRemaining);
         dStr_append_l(output, inputPtr, copylen);
         chunkRemaining -= copylen;
         inputRemaining -= copylen;
         inputPtr += copylen;
      }
 
      if ((chunkRemaining == 2) && (inputRemaining > 0)) {
         /* CR to discard */
         chunkRemaining--;
         inputRemaining--;
         inputPtr++;
      }
      if ((chunkRemaining == 1) && (inputRemaining > 0)) {
         /* LF to discard */
         chunkRemaining--;
         inputRemaining--;
         inputPtr++;
      }
 
      /*
       * A chunk has a one-line header that begins with the chunk length
       * in hexadecimal.
       */
      if (!(eol = (char *)memchr(inputPtr, '\n', inputRemaining))) {
         break;   /* We don't have the whole line yet. */
      }
 
      if (!(chunkRemaining = strtol(inputPtr, NULL, 0x10))) {
         dc->finished = TRUE;
         break;   /* A chunk length of 0 means we're done! */
      }
      inputRemaining -= (eol - inputPtr) + 1;
      inputPtr = eol + 1;
      chunkRemaining += 2; /* CRLF at the end of every chunk */
   }
 
   /* If we have a partial chunk header, save it for next time. */
   dStr_erase(dc->leftover, 0, inputPtr - dc->leftover->str);
 
   *(int *)dc->state = chunkRemaining;
   return output;
}
 
bool_t a_Decode_transfer_finished(DecodeTransfer *dc)
{
   return dc->finished;
}
 
void a_Decode_transfer_free(DecodeTransfer *dc)
{
   dFree(dc->state);
   dStr_free(dc->leftover, 1);
   dFree(dc);
}
 
static void Decode_compression_free(Decode *dc)
{
   (void)inflateEnd((z_stream *)dc->state);
 
   dFree(dc->state);
   dFree(dc->buffer);
}
 
/*
 * BUG: A fair amount of duplicated code exists in the gzip/deflate decoding,
 * but an attempt to pull out the common code left everything too contorted
 * for what it accomplished.
 */
 
static Dstr *Decode_gzip(Decode *dc, const char *instr, int inlen)
{
   int rc = Z_OK;
 
   z_stream *zs = (z_stream *)dc->state;
 
   int inputConsumed = 0;
   Dstr *output = dStr_new("");
 
   while ((rc == Z_OK) && (inputConsumed < inlen)) {
      zs->next_in = (Bytef *)instr + inputConsumed;
      zs->avail_in = inlen - inputConsumed;
 
      zs->next_out = (Bytef *)dc->buffer;
      zs->avail_out = bufsize;
 
      rc = inflate(zs, Z_SYNC_FLUSH);
 
      dStr_append_l(output, dc->buffer, zs->total_out);
 
      if ((rc == Z_OK) || (rc == Z_STREAM_END)) {
         // Z_STREAM_END at end of file
 
         inputConsumed += zs->total_in;
         zs->total_out = 0;
         zs->total_in = 0;
      } else if (rc == Z_DATA_ERROR) {
         MSG_ERR("gzip decompression error\n");
      }
   }
   return output;
}
 
static Dstr *Decode_raw_deflate(Decode *dc, const char *instr, int inlen)
{
   int rc = Z_OK;
 
   z_stream *zs = (z_stream *)dc->state;
 
   int inputConsumed = 0;
   Dstr *output = dStr_new("");
 
   while ((rc == Z_OK) && (inputConsumed < inlen)) {
      zs->next_in = (Bytef *)instr + inputConsumed;
      zs->avail_in = inlen - inputConsumed;
 
      zs->next_out = (Bytef *)dc->buffer;
      zs->avail_out = bufsize;
 
      rc = inflate(zs, Z_SYNC_FLUSH);
 
      dStr_append_l(output, dc->buffer, zs->total_out);
 
      if ((rc == Z_OK) || (rc == Z_STREAM_END)) {
         // Z_STREAM_END at end of file
 
         inputConsumed += zs->total_in;
         zs->total_out = 0;
         zs->total_in = 0;
      } else if (rc == Z_DATA_ERROR) {
         MSG_ERR("raw deflate decompression also failed\n");
      }
   }
   return output;
}
 
static Dstr *Decode_deflate(Decode *dc, const char *instr, int inlen)
{
   int rc = Z_OK;
 
   z_stream *zs = (z_stream *)dc->state;
 
   int inputConsumed = 0;
   Dstr *output = dStr_new("");
 
   while ((rc == Z_OK) && (inputConsumed < inlen)) {
      zs->next_in = (Bytef *)instr + inputConsumed;
      zs->avail_in = inlen - inputConsumed;
 
      zs->next_out = (Bytef *)dc->buffer;
      zs->avail_out = bufsize;
 
      rc = inflate(zs, Z_SYNC_FLUSH);
 
      dStr_append_l(output, dc->buffer, zs->total_out);
 
      if ((rc == Z_OK) || (rc == Z_STREAM_END)) {
         // Z_STREAM_END at end of file
 
         inputConsumed += zs->total_in;
         zs->total_out = 0;
         zs->total_in = 0;
      } else if (rc == Z_DATA_ERROR) {
         MSG_WARN("Deflate decompression error. Certain servers illegally fail"
                 " to send data in a zlib wrapper. Let's try raw deflate.\n");
         dStr_free(output, 1);
         (void)inflateEnd(zs);
         dFree(dc->state);
         dc->state = zs = dNew(z_stream, 1);
         zs->zalloc = NULL;
         zs->zfree = NULL;
         zs->next_in = NULL;
         zs->avail_in = 0;
         dc->decode = Decode_raw_deflate;
 
         // Negative value means that we want raw deflate.
         inflateInit2(zs, -MAX_WBITS);
 
         return Decode_raw_deflate(dc, instr, inlen);
      }
   }
   return output;
}
 
#ifdef ENABLE_BROTLI
static Dstr *Decode_brotli_process(Decode *dc, const char *instr, int inlen)
{
   Dstr *output = dStr_new("");
   BrotliDecoderState *st = (BrotliDecoderState *) dc->state;
 
   const uint8_t *next_in = (const uint8_t *) instr;
   size_t avail_in = inlen;
   BrotliDecoderResult res;
 
   _MSG("Decode_brotli_process inlen=%d\n", inlen);
 
   /* Handle empty case */
   if (avail_in == 0)
      return output;
 
   do {
      /* Always reset output buffer */
      uint8_t *next_out = (uint8_t *) dc->buffer;
      size_t avail_out = bufsize;
 
      _MSG("Decode_brotli_process decoding %zd bytes\n", avail_in);
 
      res = BrotliDecoderDecompressStream(st,
            &avail_in, &next_in, &avail_out, &next_out, NULL);
 
      _MSG("Decode_brotli_process res=%d\n", res);
 
      if (res == BROTLI_DECODER_RESULT_ERROR) {
         MSG_ERR("brotli decompression error\n");
         break;
      }
 
      size_t delta = bufsize - avail_out;
      _MSG("Decode_brotli_process delta=%zd\n", delta);
      dStr_append_l(output, dc->buffer, delta);
 
   } while (res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
 
   _MSG("Decode_brotli_process exitting with res=%d\n", res);
 
   return output;
}
 
static void Decode_brotli_free(Decode *dc)
{
   BrotliDecoderState *st = (BrotliDecoderState *) dc->state;
   BrotliDecoderDestroyInstance(st);
 
   dFree(dc->buffer);
}
 
static Decode *Decode_brotli_init(void)
{
   BrotliDecoderState *st = BrotliDecoderCreateInstance(NULL, NULL, NULL);
   if (st == NULL) {
      MSG_ERR("Cannot create brotli decoder instance\n");
      return NULL;
   }
 
   Decode *dc = dNew0(Decode, 1);
 
   dc->buffer = dNew(char, bufsize);
   dc->state = st;
   dc->leftover = NULL; /* not used */
   dc->decode = Decode_brotli_process;
   dc->free = Decode_brotli_free;
 
   return dc;
}
#endif /* ENABLE_BROTLI */
 
 
static Dstr *Decode_charset(Decode *dc, const char *instr, int inlen)
{
   inbuf_t *inPtr;
   char *outPtr;
   size_t inLeft, outRoom;
 
   Dstr *output = dStr_new("");
   int rc = 0;
 
   dStr_append_l(dc->leftover, instr, inlen);
   inPtr = dc->leftover->str;
   inLeft = dc->leftover->len;
 
   while ((rc != EINVAL) && (inLeft > 0)) {
 
      outPtr = dc->buffer;
      outRoom = bufsize;
 
      rc = iconv((iconv_t)dc->state, &inPtr, &inLeft, &outPtr, &outRoom);
 
      // iconv() on success, number of bytes converted
      //         -1, errno == EILSEQ illegal byte sequence found
      //                      EINVAL partial character ends source buffer
      //                      E2BIG  destination buffer is full
 
      dStr_append_l(output, dc->buffer, bufsize - outRoom);
 
      if (rc == -1)
         rc = errno;
      if (rc == EILSEQ){
         inPtr++;
         inLeft--;
         dStr_append_l(output, utf8_replacement_char,
                       sizeof(utf8_replacement_char) - 1);
      }
   }
   dStr_erase(dc->leftover, 0, dc->leftover->len - inLeft);
 
   return output;
}
 
static void Decode_charset_free(Decode *dc)
{
   /* iconv_close() frees dc->state */
   (void)iconv_close((iconv_t)(dc->state));
 
   dFree(dc->buffer);
   dStr_free(dc->leftover, 1);
}
 
DecodeTransfer *a_Decode_transfer_init(const char *format)
{
   DecodeTransfer *dc = NULL;
 
   if (format && !dStrAsciiCasecmp(format, "chunked")) {
      int *chunk_remaining = dNew(int, 1);
      *chunk_remaining = 0;
      dc = dNew(DecodeTransfer, 1);
      dc->leftover = dStr_new("");
      dc->state = chunk_remaining;
      dc->finished = FALSE;
      _MSG("chunked!\n");
   }
   return dc;
}
 
static Decode *Decode_content_init_common(void)
{
   z_stream *zs = dNew(z_stream, 1);
   Decode *dc = dNew(Decode, 1);
 
   zs->zalloc = NULL;
   zs->zfree = NULL;
   zs->next_in = NULL;
   zs->avail_in = 0;
   dc->state = zs;
   dc->buffer = dNew(char, bufsize);
 
   dc->free = Decode_compression_free;
   dc->leftover = NULL; /* not used */
   return dc;
}
 
Decode *a_Decode_content_init(const char *format)
{
   z_stream *zs;
   Decode *dc = NULL;
 
   if (format && *format) {
      if (!dStrAsciiCasecmp(format, "gzip") ||
          !dStrAsciiCasecmp(format, "x-gzip")) {
         _MSG("gzipped data!\n");
 
         dc = Decode_content_init_common();
         zs = (z_stream *)dc->state;
         /* 16 is a magic number for gzip decoding */
         inflateInit2(zs, MAX_WBITS+16);
 
         dc->decode = Decode_gzip;
      } else if (!dStrAsciiCasecmp(format, "deflate")) {
         _MSG("deflated data!\n");
 
         dc = Decode_content_init_common();
         zs = (z_stream *)dc->state;
         inflateInit(zs);
 
         dc->decode = Decode_deflate;
#ifdef ENABLE_BROTLI
      } else if (!dStrAsciiCasecmp(format, "br")) {
         _MSG("brotli data!\n");
         dc = Decode_brotli_init();
#endif
      } else {
         MSG("Content-Encoding '%s' not recognized.\n", format);
      }
   }
   return dc;
}
 
Decode *a_Decode_charset_init(const char *format)
{
   Decode *dc = NULL;
 
   if (format &&
       strlen(format) &&
       dStrAsciiCasecmp(format,"UTF-8")) {
 
      iconv_t ic = iconv_open("UTF-8", format);
      if (ic != (iconv_t) -1) {
           dc = dNew(Decode, 1);
           dc->state = ic;
           dc->buffer = dNew(char, bufsize);
           dc->leftover = dStr_new("");
 
           dc->decode = Decode_charset;
           dc->free = Decode_charset_free;
      } else {
         MSG_WARN("Unable to convert from character encoding: '%s'\n", format);
      }
   }
   return dc;
}
 
Dstr *a_Decode_process(Decode *dc, const char *instr, int inlen)
{
   return dc->decode(dc, instr, inlen);
}
 
/*
 * Free the decoder.
 */
void a_Decode_free(Decode *dc)
{
   if (dc) {
      dc->free(dc);
      dFree(dc);
   }
}