- Made an input preserving decoder implementation.

4 files changed, 72 insertions, 104 deletions

diff --git a/src/cache.c b/src/cache.c
index 88cecc9b..dc8228f1 100644
--- a/src/cache.c
+++ b/src/cache.c
@@ -642,8 +642,8 @@ void a_Cache_process_dbuf(int Op, const char *buf, size_t buf_size,
 {
    int offset = 0;
    int len;
+   const char *str;
    CacheEntry_t *entry = Cache_entry_search(Url);
-   Dstr *dbuf;
 
    /* Assert a valid entry (not aborted) */
    dReturn_if_fail (entry != NULL);
@@ -690,25 +690,30 @@ void a_Cache_process_dbuf(int Op, const char *buf, size_t buf_size,
    if (!(entry->Flags & CA_GotHeader))
       return;
 
-   entry->TransferSize += buf_size - offset;
+   str = buf + offset;
+   len = buf_size - offset;
+   entry->TransferSize += len;
 
-   dbuf = dStr_sized_new(buf_size - offset);
-   dStr_append_l(dbuf, buf + offset, buf_size - offset);
-
-   /* Assert we have a Decoder.
-    * BUG: this is a workaround, more study and a proper design
-    * for handling redirects is required */
-   if (entry->TransferDecoder != NULL) {
-      dbuf = a_Decode_process(entry->TransferDecoder, dbuf);
+   if (entry->TransferDecoder) {
+      Dstr *dbuf = a_Decode_process(entry->TransferDecoder, str, len);
+      str = dbuf->str;
+      len = dbuf->len;
+      dStr_free(dbuf, 0);
    }
-   if (entry->ContentDecoder != NULL) {
-      dbuf = a_Decode_process(entry->ContentDecoder, dbuf);
+   if (entry->ContentDecoder) {
+      Dstr *dbuf = a_Decode_process(entry->ContentDecoder, str, len);
+      if (entry->TransferDecoder)
+         dFree((char *)str);
+      str = dbuf->str;
+      len = dbuf->len;
+      dStr_free(dbuf, 0);
    }
+   dStr_append_l(entry->Data, str, len);
+   if (entry->TransferDecoder || entry->ContentDecoder)
+      dFree((char *)str);
 
-   dStr_append_l(entry->Data, dbuf->str, dbuf->len);
    if (entry->Data->len)
       entry->Flags &= ~CA_IsEmpty;
-   dStr_free(dbuf, 1);
 
    Cache_process_queue(entry);
 }
diff --git a/src/decode.c b/src/decode.c
index 1bc54372..6846c820 100644
--- a/src/decode.c
+++ b/src/decode.c
@@ -7,36 +7,21 @@
 #include "decode.h"
 #include "msg.h"
 
-
 static const int bufsize = 8*1024;
 
 /*
- * null ("identity") decoding
- */
-static Dstr *Decode_null(Decode *dc, Dstr *input)
-{
-   return input;
-}
-
-static void Decode_null_free(Decode *dc)
-{
-}
-
-/*
  * Decode chunked data
  */
-static Dstr *Decode_chunked(Decode *dc, Dstr *input)
+static Dstr *Decode_chunked(Decode *dc, const char *instr, int inlen)
 {
    char *inputPtr, *eol;
    int inputRemaining;
    int chunkRemaining = *((int *)dc->state);
-   Dstr *output = dStr_sized_new(input->len);
+   Dstr *output = dStr_sized_new(inlen);
 
-   dStr_append_l(dc->leftover, input->str, input->len);
-   dStr_free(input, 1);
-   input = dc->leftover;
-   inputPtr = input->str;
-   inputRemaining = input->len;
+   dStr_append_l(dc->leftover, instr, inlen);
+   inputPtr = dc->leftover->str;
+   inputRemaining = dc->leftover->len;
 
    while (inputRemaining > 0) {
       if (chunkRemaining > 2) {
@@ -78,8 +63,7 @@ static Dstr *Decode_chunked(Decode *dc, Dstr *input)
    }
 
    /* If we have a partial chunk header, save it for next time. */
-   dc->leftover = input;
-   dStr_erase(dc->leftover, 0, inputPtr - input->str);
+   dStr_erase(dc->leftover, 0, inputPtr - dc->leftover->str);
 
    *(int *)dc->state = chunkRemaining;
    return output;
@@ -94,7 +78,7 @@ static void Decode_chunked_free(Decode *dc)
 /*
  * Decode gzipped data
  */
-static Dstr *Decode_gzip(Decode *dc, Dstr *input)
+static Dstr *Decode_gzip(Decode *dc, const char *instr, int inlen)
 {
    int rc = Z_OK;
 
@@ -103,9 +87,9 @@ static Dstr *Decode_gzip(Decode *dc, Dstr *input)
    int inputConsumed = 0;
    Dstr *output = dStr_new("");
 
-   while ((rc == Z_OK) && (inputConsumed < input->len)) {
-      zs->next_in = (Bytef *)input->str + inputConsumed;
-      zs->avail_in = input->len - inputConsumed;
+   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;
@@ -123,8 +107,6 @@ static Dstr *Decode_gzip(Decode *dc, Dstr *input)
          zs->total_in = 0;
       }
    }
-
-   dStr_free(input, 1);
    return output;
 }
 
@@ -138,24 +120,18 @@ static void Decode_gzip_free(Decode *dc)
 /*
  * Translate to desired character set (UTF-8)
  */
-static Dstr *Decode_charset(Decode *dc, Dstr *input)
+static Dstr *Decode_charset(Decode *dc, const char *instr, int inlen)
 {
-   int rc = 0;
-
-   Dstr *output;
    inbuf_t *inPtr;
    char *outPtr;
    size_t inLeft, outRoom;
 
-   output = dStr_new("");
-
-   dStr_append_l(dc->leftover, input->str, input->len);
-   dStr_free(input, 1);
-   input = dc->leftover;
-
-   inPtr = input->str;
-   inLeft = input->len;
+   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)) {
 
@@ -187,8 +163,6 @@ static Dstr *Decode_charset(Decode *dc, Dstr *input)
           dStr_append_c(output, 0xBD);
       }
    }
-
-   dc->leftover = input;
    dStr_erase(dc->leftover, 0, dc->leftover->len - inLeft);
 
    return output;
@@ -207,24 +181,18 @@ static void Decode_charset_free(Decode *dc)
  */
 Decode *a_Decode_transfer_init(const char *format)
 {
-   Decode *dc = (Decode *)dMalloc(sizeof(Decode));
-
-   /* not used */
-   dc->buffer = NULL;
-
-   dc->leftover = dStr_new("");
+   Decode *dc = NULL;
 
    if (format && !dStrncasecmp(format, "chunked", 7)) {
-      int *chunk_remaining = (int *)dMalloc(sizeof(int));
+      int *chunk_remaining = dNew(int, 1);
       *chunk_remaining = 0;
+      dc = dNew(Decode, 1);
+      dc->leftover = dStr_new("");
       dc->state = chunk_remaining;
       dc->decode = Decode_chunked;
       dc->free = Decode_chunked_free;
+      dc->buffer = NULL; /* not used */
       MSG("chunked!\n");
-   } else {
-      dc->state = NULL;
-      dc->decode = Decode_null;
-      dc->free = Decode_null_free;
    }
    return dc;
 }
@@ -237,21 +205,15 @@ Decode *a_Decode_transfer_init(const char *format)
  */
 Decode *a_Decode_content_init(const char *format)
 {
-   Decode *dc = (Decode *)dMalloc(sizeof(Decode));
-
-   dc->buffer = NULL;
-   dc->state = NULL;
-
-   /* not used */
-   dc->leftover = NULL;
+   Decode *dc = NULL;
 
    if (format && !dStrcasecmp(format, "gzip")) {
+      MSG("gzipped data!\n");
 
-      MSG("compressed data! : %s\n", format);
-      
       z_stream *zs;
-      dc->buffer = (char *)dMalloc(bufsize);
-      dc->state = zs = (z_stream *)dMalloc(sizeof(z_stream));
+      dc = dNew(Decode, 1);
+      dc->buffer = dNew(char, bufsize);
+      dc->state = zs = dNew(z_stream, 1);
       zs->zalloc = NULL;
       zs->zfree = NULL;
       zs->next_in = NULL;
@@ -262,9 +224,7 @@ Decode *a_Decode_content_init(const char *format)
 
       dc->decode = Decode_gzip;
       dc->free = Decode_gzip_free;
-   } else {
-      dc->decode = Decode_null;
-      dc->free = Decode_null_free;
+      dc->leftover = NULL; /* not used */
    }
    return dc;      
 }
@@ -296,30 +256,26 @@ static int Decode_is_ascii(const char *str)
  */
 Decode *a_Decode_charset_init(const char *format)
 {
-   Decode *dc = (Decode *)dMalloc(sizeof(Decode));
+   Decode *dc = NULL;
 
    if (format &&
        strlen(format) &&
        dStrcasecmp(format,"UTF-8") &&
        !Decode_is_ascii(format)) {
 
-      iconv_t ic;
-      dc->state = ic = iconv_open("UTF-8", format);
+      iconv_t ic = iconv_open("UTF-8", format);
       if (ic != (iconv_t) -1) {
-           dc->buffer = (char *)dMalloc(bufsize);
+           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;
-           return dc;
       } else {
          MSG("Unable to convert from character encoding: '%s'\n", format);
       }
    }
-   dc->leftover = NULL;
-   dc->buffer = NULL;
-   dc->decode = Decode_null;
-   dc->free = Decode_null_free;
    return dc;      
 }
 
@@ -329,16 +285,18 @@ Decode *a_Decode_charset_init(const char *format)
  * The input string should not be used after this call. The decoder will
  * free it if necessary.
  */
-Dstr *a_Decode_process(Decode *dc, Dstr *input)
+Dstr *a_Decode_process(Decode *dc, const char *instr, int inlen)
 {
-   return dc->decode(dc, input);
+   return dc->decode(dc, instr, inlen);
 }
 
 /*
- * free our decoder
+ * Free the decoder.
  */
 void a_Decode_free(Decode *dc)
 {
-   dc->free(dc);
-   dFree(dc);
+   if (dc) {
+      dc->free(dc);
+      dFree(dc);
+   }
 }
diff --git a/src/decode.h b/src/decode.h
index b3f56eb3..064177eb 100644
--- a/src/decode.h
+++ b/src/decode.h
@@ -13,14 +13,14 @@ struct _Decode {
    char *buffer;
    Dstr *leftover;
    void *state;
-   Dstr *(*decode) (Decode *dc, Dstr *input);
+   Dstr *(*decode) (Decode *dc, const char *instr, int inlen);
    void (*free) (Decode *dc);
 };
 
 Decode *a_Decode_transfer_init(const char *format);
 Decode *a_Decode_content_init(const char *format);
 Decode *a_Decode_charset_init(const char *format);
-Dstr *a_Decode_process(Decode *dc, Dstr *input);
+Dstr *a_Decode_process(Decode *dc, const char *instr, int inlen);
 void a_Decode_free(Decode *dc);
 
 #ifdef __cplusplus
diff --git a/src/html.cc b/src/html.cc
index 94ce41c1..617188e2 100644
--- a/src/html.cc
+++ b/src/html.cc
@@ -958,17 +958,22 @@ void DilloHtml::connectSignals(Widget *dw)
 void DilloHtml::write(char *Buf, int BufSize, int Eof)
 {
    int token_start;
-   Dstr *new_text;
+   Dstr *new_text = NULL;
 
    dReturn_if_fail (dw != NULL);
 
-   new_text = dStr_sized_new(BufSize - Buf_Consumed);
-   dStr_append_l(new_text, Buf + Buf_Consumed, BufSize - Buf_Consumed);
+   char *str = Buf + Buf_Consumed;
+   int len = BufSize - Buf_Consumed;
 
    /* decode to target charset (UTF-8) */
-   new_text = a_Decode_process(decoder, new_text);
-   dStr_append_l(Local_Buf, new_text->str, new_text->len);
-   dStr_free(new_text, 1);
+   if (decoder) {
+      new_text = a_Decode_process(decoder, str, len);
+      str = new_text->str;
+      len = new_text->len;
+   }
+   dStr_append_l(Local_Buf, str, len);
+   if (decoder)
+      dStr_free(new_text, 1);
 
    token_start = Html_write_raw(this, Local_Buf->str + Local_Ofs,
                                 Local_Buf->len - Local_Ofs, Eof);
@@ -4009,7 +4014,7 @@ static Dstr *Html_encode_text(iconv_t encoder, Dstr **input)
    output = dStr_new("");
    inPtr  = (*input)->str;
    inLeft = (*input)->len;
-   buffer = (char *)dMalloc(bufsize);
+   buffer = dNew(char, bufsize);
 
    while ((rc != EINVAL) && (inLeft > 0)) {