src/fmtutil-lzw.c

   1 // This file is part of Deark.
   2 // Copyright (C) 2019 Jason Summers
   3 // See the file COPYING for terms of use.
   4
   5 // LZW decompressor
   6
   7 #define DE_NOT_IN_MODULE
   8 #include "deark-config.h"
   9 #include "deark-private.h"
  10 #include "deark-fmtutil.h"
  11
  12 static void *my_delzw_calloc(void *userdata, size_t nmemb, size_t size);
  13 static void my_delzw_free(void *userdata, void *ptr);
  14
  15 #define DELZW_UINT8   u8
  16 #define DELZW_UINT16  u16
  17 #define DELZW_UINT32  u32
  18 #define DELZW_OFF_T   i64
  19 #define DELZW_MEMCPY  de_memcpy
  20 #define DELZW_STRLCPY de_strlcpy
  21 #define DELZW_VSNPRINTF de_vsnprintf
  22 #define DELZW_GNUC_ATTRIBUTE de_gnuc_attribute
  23 #define DELZW_CALLOC(u, nmemb, size, ty) my_delzw_calloc((u), (nmemb), (size))
  24 #define DELZW_FREE      my_delzw_free
  25
  26 #include "../foreign/delzw.h"
  27
  28 ///////////////////////////////////////////////////
  29
  30 static void setup_delzw_common(deark *c, delzwctx *dc, struct de_lzw_params *delzwp)
  31 {
  32         dc->debug_level = c->debug_level;
  33
  34         if(delzwp->fmt==DE_LZWFMT_UNIXCOMPRESS) {
  35                 dc->basefmt = DELZW_BASEFMT_UNIXCOMPRESS;
  36                 dc->auto_inc_codesize = 1;
  37                 if(delzwp->flags & DE_LZWFLAG_HAS3BYTEHEADER) {
  38                         dc->header_type = DELZW_HEADERTYPE_UNIXCOMPRESS3BYTE;
  39                 }
  40                 else if(delzwp->flags & DE_LZWFLAG_HAS1BYTEHEADER) {
  41                         dc->header_type = DELZW_HEADERTYPE_ARC1BYTE;
  42                 }
  43                 else {
  44                         dc->unixcompress_has_clear_code = 1;
  45                         dc->max_codesize = delzwp->max_code_size;
  46                 }
  47
  48                 if((delzwp->flags & DE_LZWFLAG_TOLERATETRAILINGJUNK) &&
  49                         !dc->output_len_known)
  50                 {
  51                         dc->stop_on_invalid_code = 1;
  52                 }
  53         }
  54         else if(delzwp->fmt==DE_LZWFMT_ZIPSHRINK) {
  55                 dc->basefmt = DELZW_BASEFMT_ZIPSHRINK;
  56         }
  57         else if(delzwp->fmt==DE_LZWFMT_GIF) {
  58                 dc->basefmt = DELZW_BASEFMT_GIF;
  59                 dc->gif_root_codesize = delzwp->gif_root_code_size;
  60         }
  61         else if(delzwp->fmt==DE_LZWFMT_ZOOLZD) {
  62                 dc->basefmt = DELZW_BASEFMT_ZOOLZD;
  63                 dc->auto_inc_codesize = 1;
  64                 dc->max_codesize = delzwp->max_code_size;
  65         }
  66 }
  67
  68 void fmtutil_decompress_lzw(deark *c, struct de_dfilter_in_params *dcmpri,
  69         struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres,
  70         struct de_lzw_params *lzwp)
  71 {
  72         de_dfilter_decompress_oneshot(c, dfilter_lzw_codec, (void*)lzwp,
  73                 dcmpri, dcmpro, dres);
  74 }
  75
  76 static size_t wrapped_dfctx_write_cb(delzwctx *dc, const DELZW_UINT8 *buf, size_t size,
  77         unsigned int *outflags)
  78 {
  79         struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx*)dc->userdata;
  80
  81         // Note: We could be writing to a custom dbuf, in which case the client has
  82         // a chance to examine the decompressed bytes, and might want to stop the
  83         // decompression based on their contents. But there's currently no way to
  84         // do that.
  85         dbuf_write(dfctx->dcmpro->f, buf, (i64)size);
  86         return size;
  87 }
  88
  89 static void wrapped_dfctx_debugmsg(delzwctx *dc, int level, const char *msg)
  90 {
  91         struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx*)dc->userdata;
  92
  93         de_dbg(dfctx->c, "[delzw:i%"I64_FMT"/o%"I64_FMT"] %s",
  94                 (i64)dc->total_nbytes_processed, (i64)dc->uncmpr_nbytes_decoded, msg);
  95 }
  96
  97 static void my_lzw_codec_finish(struct de_dfilter_ctx *dfctx)
  98 {
  99         const char *modname = "delzw";
 100         delzwctx *dc = (delzwctx*)dfctx->codec_private;
 101
 102         if(!dc) return;
 103         delzw_finish(dc);
 104
 105         dfctx->dres->bytes_consumed = dc->total_nbytes_processed;
 106         dfctx->dres->bytes_consumed_valid = 1;
 107
 108         if(dc->errcode) {
 109                 de_dfilter_set_errorf(dfctx->c, dfctx->dres, modname, "%s", dc->errmsg);
 110         }
 111 }
 112
 113 static void my_lzw_codec_addbuf(struct de_dfilter_ctx *dfctx,
 114         const u8 *buf, i64 buf_len)
 115 {
 116         delzwctx *dc = (delzwctx*)dfctx->codec_private;
 117
 118         if(!dc) return;
 119         delzw_addbuf(dc, buf, (size_t)buf_len);
 120         if(dc->state == DELZW_STATE_FINISHED) {
 121                 dfctx->finished_flag = 1;
 122         }
 123 }
 124
 125 static void my_lzw_codec_destroy(struct de_dfilter_ctx *dfctx)
 126 {
 127         delzwctx *dc = (delzwctx*)dfctx->codec_private;
 128
 129         delzw_destroy(dc);
 130         dfctx->codec_private = NULL;
 131 }
 132
 133 // Print dbg messages and warnings about the header
 134 static void my_lzw_after_header_parsed(delzwctx *dc)
 135 {
 136         struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx *)dc->userdata;
 137         deark *c = dfctx->c;
 138
 139         if(dc->header_type==DELZW_HEADERTYPE_UNIXCOMPRESS3BYTE) {
 140                 de_dbg(c, "LZW mode: 0x%02x", (unsigned int)dc->header_unixcompress_mode);
 141                 de_dbg_indent(c, 1);
 142                 de_dbg(c, "maxbits: %u", (unsigned int)dc->header_unixcompress_max_codesize);
 143                 de_dbg(c, "blockmode: %d", (int)dc->header_unixcompress_block_mode);
 144                 if(!dc->header_unixcompress_block_mode) {
 145                         de_warn(c, "This file uses an obsolete compress'd format, which "
 146                                 "might not be decompressed correctly");
 147                 }
 148                 de_dbg_indent(c, -1);
 149         }
 150         else if(dc->header_type==DELZW_HEADERTYPE_ARC1BYTE) {
 151                 de_dbg(c, "LZW maxbits: %u", (unsigned int)dc->header_unixcompress_max_codesize);
 152         }
 153 }
 154
 155 static void *my_delzw_calloc(void *userdata, size_t nmemb, size_t size)
 156 {
 157         struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx*)userdata;
 158
 159         return de_mallocarray(dfctx->c, (i64)nmemb, size);
 160 }
 161
 162 static void my_delzw_free(void *userdata, void *ptr)
 163 {
 164         struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx*)userdata;
 165
 166         de_free(dfctx->c, ptr);
 167 }
 168
 169 // codec_private_params is type struct de_lzw_params.
 170 void dfilter_lzw_codec(struct de_dfilter_ctx *dfctx, void *codec_private_params)
 171 {
 172         delzwctx *dc = NULL;
 173         struct de_lzw_params *delzwp = (struct de_lzw_params*)codec_private_params;
 174
 175         dc = delzw_create((void*)dfctx);
 176         if(!dc) goto done;
 177         dfctx->codec_private = (void*)dc;
 178         dfctx->codec_finish_fn = my_lzw_codec_finish;
 179         dfctx->codec_destroy_fn = my_lzw_codec_destroy;
 180         dfctx->codec_addbuf_fn = my_lzw_codec_addbuf;
 181
 182         dc->cb_write = wrapped_dfctx_write_cb;
 183         dc->cb_debugmsg = wrapped_dfctx_debugmsg;
 184         dc->cb_after_header_parsed = my_lzw_after_header_parsed;
 185         dc->output_len_known = dfctx->dcmpro->len_known;
 186         dc->output_expected_len = dfctx->dcmpro->expected_len;
 187
 188         setup_delzw_common(dfctx->c, dc, delzwp);
 189 done:
 190         ;
 191 }