compress_zstd.cc

   1 /*
   2  * Copyright (c) 2018, Cygwin
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     A copy of the GNU General Public License can be found at
  10  *     http://www.gnu.org/
  11  *
  12  */
  13
  14 #include "compress_zstd.h"
  15
  16 #include <stdexcept>
  17
  18 #include <errno.h>
  19 #include <memory.h>
  20 #include <malloc.h>
  21
  22 /*
  23  * Predicate: the stream is open for read.
  24  */
  25 compress_zstd::compress_zstd (io_stream * parent)
  26 :
  27   original(NULL),
  28   owns_original(true),
  29   lasterr(0)
  30 {
  31   /* read only */
  32   if (!parent || parent->error())
  33     {
  34       lasterr = EBADF;
  35       return;
  36     }
  37   original = parent;
  38   create();
  39 }
  40
  41 void
  42 compress_zstd::create (void)
  43 {
  44   state = (struct private_data *)calloc(sizeof(*state), 1);
  45   if (state == NULL)
  46     {
  47       free(state);
  48       lasterr = ENOMEM;
  49       return;
  50     }
  51
  52   state->stream = ZSTD_createDStream();
  53   if (state->stream == NULL)
  54     {
  55       free(state);
  56       lasterr = ENOMEM;
  57       return;
  58     }
  59   ZSTD_initDStream(state->stream);
  60   state->out_block.size = state->out_block.pos  = state->out_pos = state->out_bsz = ZSTD_DStreamOutSize();
  61   state->out_block.dst  = (unsigned char *)malloc(state->out_bsz);
  62   if (state->out_block.dst == NULL)
  63     {
  64       free(state->out_block.dst);
  65       free(state);
  66       lasterr = ENOMEM;
  67       return;
  68     }
  69   state->in_block.size = state->in_block.pos  = state->in_bsz = ZSTD_DStreamInSize();
  70   state->in_block.src  = (unsigned char *)malloc(state->in_bsz);
  71   state->in_pos  = 0;
  72   if (state->in_block.src == NULL)
  73     {
  74       free(state->out_block.dst);
  75       free((void*)state->in_block.src);
  76       free(state);
  77       lasterr = ENOMEM;
  78       return;
  79     }
  80 }
  81
  82 ssize_t
  83 compress_zstd::read (void *buffer, size_t len)
  84 {
  85   /* there is no recovery from a busted stream */
  86   if (this->lasterr)
  87     {
  88       return -1;
  89     }
  90   if (len == 0)
  91     {
  92       return 0;
  93     }
  94
  95   size_t lenRemaining = len;
  96   size_t lenBuffered  = 0;
  97   do
  98     {
  99       if (state->in_block.size > 0 && state->in_block.pos >= state->in_block.size)
 100         {
 101           /* no compressed data ready; read some more input */
 102           state->in_block.size = state->in_bsz;
 103           ssize_t got = this->original->read((void *)state->in_block.src, state->in_bsz);
 104           if (got >= 0)
 105             {
 106               state->in_block.size = got;
 107               state->in_block.pos = 0;
 108             }
 109           else
 110             {
 111               lasterr = EIO;
 112               return -1;
 113             }
 114           continue;
 115         }
 116
 117       if (state->out_pos < state->out_block.pos)
 118         {
 119           /* output buffer has unused data */
 120           ssize_t tmplen = std::min (state->out_block.pos - state->out_pos, lenRemaining);
 121           memcpy (&((char *)buffer)[lenBuffered], &((char *)state->out_block.dst)[state->out_pos], tmplen);
 122           state->out_pos += tmplen;
 123           lenBuffered    += tmplen;
 124           lenRemaining   -= tmplen;
 125           if (state->eof)
 126             {
 127               break;
 128             }
 129         }
 130       else
 131         {
 132           if (state->eof)
 133             {
 134               break;
 135             }
 136           /* output buffer is empty; decompress more data */
 137           state->out_block.size = state->out_bsz;
 138           state->out_pos = state->out_block.pos = 0;
 139           size_t ret = ZSTD_decompressStream (state->stream, &state->out_block, &state->in_block);
 140           if (ZSTD_isError(ret))
 141             {
 142               // TODO return/print error
 143               return -1;
 144             }
 145           state->eof = (ret == 0);
 146         }
 147     }
 148   while (lenRemaining != 0);
 149
 150   return (len - lenRemaining);
 151 }
 152
 153 ssize_t
 154 compress_zstd::write (const void *buffer, size_t len)
 155 {
 156   throw new std::logic_error("compress_zstd::write is not implemented");
 157 }
 158
 159 ssize_t
 160 compress_zstd::peek (void *buffer, size_t len)
 161 {
 162   /* can only peek 512 bytes */
 163   if (len > 512)
 164     return ENOMEM;
 165
 166   // we only peek at the beginning of a file, so no buffer tearing can happen
 167   // do a real read first…
 168   ssize_t got = read (buffer, len);
 169   if (got >= 0)
 170     {
 171       // …then rewind read position for the next read()
 172       state->out_pos -= got;
 173     }
 174   /* error */
 175   return got;
 176 }
 177
 178 off_t
 179 compress_zstd::tell ()
 180 {
 181   throw new std::logic_error("compress_zstd::tell is not implemented");
 182 }
 183
 184 off_t
 185 compress_zstd::seek (off_t where, io_stream_seek_t whence)
 186 {
 187   if ((whence == IO_SEEK_SET) && (where == 0))
 188     {
 189       off_t result = original->seek(where, whence);
 190       destroy();
 191       create();
 192       return result;
 193     }
 194
 195   throw new std::logic_error("compress_zstd::seek is not implemented");
 196 }
 197
 198 int
 199 compress_zstd::error ()
 200 {
 201   return lasterr;
 202 }
 203
 204 int
 205 compress_zstd::set_mtime (time_t mtime)
 206 {
 207   if (original)
 208     return original->set_mtime (mtime);
 209   return 1;
 210 }
 211
 212 time_t
 213 compress_zstd::get_mtime ()
 214 {
 215   if (original)
 216     return original->get_mtime ();
 217   return 0;
 218 }
 219
 220 mode_t
 221 compress_zstd::get_mode ()
 222 {
 223   if (original)
 224     return original->get_mode ();
 225   return 0;
 226 }
 227
 228 void
 229 compress_zstd::release_original ()
 230 {
 231   owns_original = false;
 232 }
 233
 234 void
 235 compress_zstd::destroy ()
 236 {
 237   if (state)
 238     {
 239       ZSTD_freeDStream(state->stream);
 240
 241       if (state->out_block.dst)
 242         {
 243           free (state->out_block.dst);
 244           state->out_block.dst = NULL;
 245         }
 246
 247       if (state->in_block.src)
 248         {
 249           free ((void*)state->in_block.src);
 250           state->in_block.src = NULL;
 251         }
 252
 253       free(state);
 254       state = NULL;
 255     }
 256 }
 257
 258 compress_zstd::~compress_zstd ()
 259 {
 260   destroy ();
 261
 262   if (original && owns_original)
 263     delete original;
 264 }
 265
 266 bool
 267 compress_zstd::is_zstd (void * buffer, size_t len)
 268 {
 269   return (ZSTD_getFrameContentSize(buffer, len) != ZSTD_CONTENTSIZE_ERROR);
 270 }