iOS/Pods/SSZipArchive/SSZipArchive/minizip/ioapi_buf.c

   1 /* ioapi_buf.c -- IO base function header for compress/uncompress .zip
   2    files using zlib + zip or unzip API
   3
   4    This version of ioapi is designed to buffer IO.
   5
   6    Copyright (C) 2012-2017 Nathan Moinvaziri
   7       https://github.com/nmoinvaz/minizip
   8
   9    This program is distributed under the terms of the same license as zlib.
  10    See the accompanying LICENSE file for the full text of the license.
  11 */
  12
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <stdarg.h>
  18
  19 #include "zlib.h"
  20 #include "ioapi.h"
  21
  22 #include "ioapi_buf.h"
  23
  24 #ifndef IOBUF_BUFFERSIZE
  25 #  define IOBUF_BUFFERSIZE (UINT16_MAX)
  26 #endif
  27
  28 #if defined(_WIN32)
  29 #  include <conio.h>
  30 #  define PRINTF  _cprintf
  31 #  define VPRINTF _vcprintf
  32 #else
  33 #  define PRINTF  printf
  34 #  define VPRINTF vprintf
  35 #endif
  36
  37 //#define IOBUF_VERBOSE
  38
  39 #ifdef __GNUC__
  40 #ifndef max
  41 #define max(x,y) ({ \
  42 const __typeof__(x) _x = (x);   \
  43 const __typeof__(y) _y = (y);   \
  44 (void) (&_x == &_y);            \
  45 _x > _y ? _x : _y; })
  46 #endif /* __GNUC__ */
  47
  48 #ifndef min
  49 #define min(x,y) ({ \
  50 const __typeof__(x) _x = (x);   \
  51 const __typeof__(y) _y = (y);   \
  52 (void) (&_x == &_y);            \
  53 _x < _y ? _x : _y; })
  54 #endif
  55 #endif
  56
  57 typedef struct ourstream_s {
  58   char      readbuf[IOBUF_BUFFERSIZE];
  59   uint32_t  readbuf_len;
  60   uint32_t  readbuf_pos;
  61   uint32_t  readbuf_hits;
  62   uint32_t  readbuf_misses;
  63   char      writebuf[IOBUF_BUFFERSIZE];
  64   uint32_t  writebuf_len;
  65   uint32_t  writebuf_pos;
  66   uint32_t  writebuf_hits;
  67   uint32_t  writebuf_misses;
  68   uint64_t  position;
  69   voidpf    stream;
  70 } ourstream_t;
  71
  72 #if defined(IOBUF_VERBOSE)
  73 #  define print_buf(o,s,f,...) print_buf_internal(o,s,f,__VA_ARGS__);
  74 #else
  75 #  define print_buf(o,s,f,...)
  76 #endif
  77
  78 void print_buf_internal(ZIP_UNUSED voidpf opaque, voidpf stream, char *format, ...)
  79 {
  80     ourstream_t *streamio = (ourstream_t *)stream;
  81     va_list arglist;
  82     PRINTF("Buf stream %p - ", streamio);
  83     va_start(arglist, format);
  84     VPRINTF(format, arglist);
  85     va_end(arglist);
  86 }
  87
  88 voidpf fopen_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, ZIP_UNUSED uint32_t number_disk, ZIP_UNUSED int mode)
  89 {
  90     ourstream_t *streamio = NULL;
  91     if (stream == NULL)
  92         return NULL;
  93     streamio = (ourstream_t *)malloc(sizeof(ourstream_t));
  94     if (streamio == NULL)
  95         return NULL;
  96     memset(streamio, 0, sizeof(ourstream_t));
  97     streamio->stream = stream;
  98     print_buf(opaque, streamio, "open [num %d mode %d]\n", number_disk, mode);
  99     return streamio;
 100 }
 101
 102 voidpf ZCALLBACK fopen_buf_func(voidpf opaque, const char *filename, int mode)
 103 {
 104     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 105     voidpf stream = bufio->filefunc.zopen_file(bufio->filefunc.opaque, filename, mode);
 106     return fopen_buf_internal_func(opaque, stream, 0, mode);
 107 }
 108
 109 voidpf ZCALLBACK fopen64_buf_func(voidpf opaque, const void *filename, int mode)
 110 {
 111     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 112     voidpf stream = bufio->filefunc64.zopen64_file(bufio->filefunc64.opaque, filename, mode);
 113     return fopen_buf_internal_func(opaque, stream, 0, mode);
 114 }
 115
 116 voidpf ZCALLBACK fopendisk_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode)
 117 {
 118     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 119     ourstream_t *streamio = (ourstream_t *)stream_cd;
 120     voidpf *stream = bufio->filefunc.zopendisk_file(bufio->filefunc.opaque, streamio->stream, number_disk, mode);
 121     return fopen_buf_internal_func(opaque, stream, number_disk, mode);
 122 }
 123
 124 voidpf ZCALLBACK fopendisk64_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode)
 125 {
 126     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 127     ourstream_t *streamio = (ourstream_t *)stream_cd;
 128     voidpf stream = bufio->filefunc64.zopendisk64_file(bufio->filefunc64.opaque, streamio->stream, number_disk, mode);
 129     return fopen_buf_internal_func(opaque, stream, number_disk, mode);
 130 }
 131
 132 long fflush_buf(voidpf opaque, voidpf stream)
 133 {
 134     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 135     ourstream_t *streamio = (ourstream_t *)stream;
 136     uint32_t total_bytes_to_write = 0;
 137     uint32_t bytes_to_write = streamio->writebuf_len;
 138     uint32_t bytes_left_to_write = streamio->writebuf_len;
 139     long bytes_written = 0;
 140
 141     while (bytes_left_to_write > 0)
 142     {
 143         if (bufio->filefunc64.zwrite_file != NULL)
 144             bytes_written = bufio->filefunc64.zwrite_file(bufio->filefunc64.opaque, streamio->stream, streamio->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
 145         else
 146             bytes_written = bufio->filefunc.zwrite_file(bufio->filefunc.opaque, streamio->stream, streamio->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
 147
 148         streamio->writebuf_misses += 1;
 149
 150         print_buf(opaque, stream, "write flush [%d:%d len %d]\n", bytes_to_write, bytes_left_to_write, streamio->writebuf_len);
 151
 152         if (bytes_written < 0)
 153             return bytes_written;
 154
 155         total_bytes_to_write += bytes_written;
 156         bytes_left_to_write -= bytes_written;
 157         streamio->position += bytes_written;
 158     }
 159     streamio->writebuf_len = 0;
 160     streamio->writebuf_pos = 0;
 161     return total_bytes_to_write;
 162 }
 163
 164 uint32_t ZCALLBACK fread_buf_func(voidpf opaque, voidpf stream, void *buf, uint32_t size)
 165 {
 166     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 167     ourstream_t *streamio = (ourstream_t *)stream;
 168     uint32_t buf_len = 0;
 169     uint32_t bytes_to_read = 0;
 170     uint32_t bytes_to_copy = 0;
 171     uint32_t bytes_left_to_read = size;
 172     uint32_t bytes_read = 0;
 173
 174     print_buf(opaque, stream, "read [size %ld pos %lld]\n", size, streamio->position);
 175
 176     if (streamio->writebuf_len > 0)
 177     {
 178         print_buf(opaque, stream, "switch from write to read, not yet supported [%lld]\n", streamio->position);
 179     }
 180
 181     while (bytes_left_to_read > 0)
 182     {
 183         if ((streamio->readbuf_len == 0) || (streamio->readbuf_pos == streamio->readbuf_len))
 184         {
 185             if (streamio->readbuf_len == IOBUF_BUFFERSIZE)
 186             {
 187                 streamio->readbuf_pos = 0;
 188                 streamio->readbuf_len = 0;
 189             }
 190
 191             bytes_to_read = IOBUF_BUFFERSIZE - (streamio->readbuf_len - streamio->readbuf_pos);
 192
 193             if (bufio->filefunc64.zread_file != NULL)
 194                 bytes_read = bufio->filefunc64.zread_file(bufio->filefunc64.opaque, streamio->stream, streamio->readbuf + streamio->readbuf_pos, bytes_to_read);
 195             else
 196                 bytes_read = bufio->filefunc.zread_file(bufio->filefunc.opaque, streamio->stream, streamio->readbuf + streamio->readbuf_pos, bytes_to_read);
 197
 198             streamio->readbuf_misses += 1;
 199             streamio->readbuf_len += bytes_read;
 200             streamio->position += bytes_read;
 201
 202             print_buf(opaque, stream, "filled [read %d/%d buf %d:%d pos %lld]\n", bytes_read, bytes_to_read, streamio->readbuf_pos, streamio->readbuf_len, streamio->position);
 203
 204             if (bytes_read == 0)
 205                 break;
 206         }
 207
 208         if ((streamio->readbuf_len - streamio->readbuf_pos) > 0)
 209         {
 210             bytes_to_copy = min(bytes_left_to_read, (uint32_t)(streamio->readbuf_len - streamio->readbuf_pos));
 211             memcpy((char *)buf + buf_len, streamio->readbuf + streamio->readbuf_pos, bytes_to_copy);
 212
 213             buf_len += bytes_to_copy;
 214             bytes_left_to_read -= bytes_to_copy;
 215
 216             streamio->readbuf_hits += 1;
 217             streamio->readbuf_pos += bytes_to_copy;
 218
 219             print_buf(opaque, stream, "emptied [copied %d remaining %d buf %d:%d pos %lld]\n", bytes_to_copy, bytes_left_to_read, streamio->readbuf_pos, streamio->readbuf_len, streamio->position);
 220         }
 221     }
 222
 223     return size - bytes_left_to_read;
 224 }
 225
 226 uint32_t ZCALLBACK fwrite_buf_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
 227 {
 228     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 229     ourstream_t *streamio = (ourstream_t *)stream;
 230     uint32_t bytes_to_write = size;
 231     uint32_t bytes_left_to_write = size;
 232     uint32_t bytes_to_copy = 0;
 233     int64_t ret = 0;
 234
 235     print_buf(opaque, stream, "write [size %ld len %d pos %lld]\n", size, streamio->writebuf_len, streamio->position);
 236
 237     if (streamio->readbuf_len > 0)
 238     {
 239         streamio->position -= streamio->readbuf_len;
 240         streamio->position += streamio->readbuf_pos;
 241
 242         streamio->readbuf_len = 0;
 243         streamio->readbuf_pos = 0;
 244
 245         print_buf(opaque, stream, "switch from read to write [%lld]\n", streamio->position);
 246
 247         if (bufio->filefunc64.zseek64_file != NULL)
 248             ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, streamio->position, ZLIB_FILEFUNC_SEEK_SET);
 249         else
 250             ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, (uint32_t)streamio->position, ZLIB_FILEFUNC_SEEK_SET);
 251
 252         if (ret != 0)
 253             return (uint32_t)-1;
 254     }
 255
 256     while (bytes_left_to_write > 0)
 257     {
 258         bytes_to_copy = min(bytes_left_to_write, (uint32_t)(IOBUF_BUFFERSIZE - min(streamio->writebuf_len, streamio->writebuf_pos)));
 259
 260         if (bytes_to_copy == 0)
 261         {
 262             if (fflush_buf(opaque, stream) <= 0)
 263                 return 0;
 264
 265             continue;
 266         }
 267
 268         memcpy(streamio->writebuf + streamio->writebuf_pos, (char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
 269
 270         print_buf(opaque, stream, "write copy [remaining %d write %d:%d len %d]\n", bytes_to_copy, bytes_to_write, bytes_left_to_write, streamio->writebuf_len);
 271
 272         bytes_left_to_write -= bytes_to_copy;
 273
 274         streamio->writebuf_pos += bytes_to_copy;
 275         streamio->writebuf_hits += 1;
 276         if (streamio->writebuf_pos > streamio->writebuf_len)
 277             streamio->writebuf_len += streamio->writebuf_pos - streamio->writebuf_len;
 278     }
 279
 280     return size - bytes_left_to_write;
 281 }
 282
 283 uint64_t ftell_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint64_t position)
 284 {
 285     ourstream_t *streamio = (ourstream_t *)stream;
 286     streamio->position = position;
 287     print_buf(opaque, stream, "tell [pos %llu readpos %d writepos %d err %d]\n", streamio->position, streamio->readbuf_pos, streamio->writebuf_pos, errno);
 288     if (streamio->readbuf_len > 0)
 289         position -= (streamio->readbuf_len - streamio->readbuf_pos);
 290     if (streamio->writebuf_len > 0)
 291         position += streamio->writebuf_pos;
 292     return position;
 293 }
 294
 295 long ZCALLBACK ftell_buf_func(voidpf opaque, voidpf stream)
 296 {
 297     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 298     ourstream_t *streamio = (ourstream_t *)stream;
 299     uint64_t position = bufio->filefunc.ztell_file(bufio->filefunc.opaque, streamio->stream);
 300     return (long)ftell_buf_internal_func(opaque, stream, position);
 301 }
 302
 303 uint64_t ZCALLBACK ftell64_buf_func(voidpf opaque, voidpf stream)
 304 {
 305     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 306     ourstream_t *streamio = (ourstream_t *)stream;
 307     uint64_t position = bufio->filefunc64.ztell64_file(bufio->filefunc64.opaque, streamio->stream);
 308     return ftell_buf_internal_func(opaque, stream, position);
 309 }
 310
 311 int fseek_buf_internal_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
 312 {
 313     ourstream_t *streamio = (ourstream_t *)stream;
 314
 315     print_buf(opaque, stream, "seek [origin %d offset %llu pos %lld]\n", origin, offset, streamio->position);
 316
 317     switch (origin)
 318     {
 319         case ZLIB_FILEFUNC_SEEK_SET:
 320
 321             if (streamio->writebuf_len > 0)
 322             {
 323                 if ((offset >= streamio->position) && (offset <= streamio->position + streamio->writebuf_len))
 324                 {
 325                     streamio->writebuf_pos = (uint32_t)(offset - streamio->position);
 326                     return 0;
 327                 }
 328             }
 329             if ((streamio->readbuf_len > 0) && (offset < streamio->position) && (offset >= streamio->position - streamio->readbuf_len))
 330             {
 331                 streamio->readbuf_pos = (uint32_t)(offset - (streamio->position - streamio->readbuf_len));
 332                 return 0;
 333             }
 334             if (fflush_buf(opaque, stream) < 0)
 335                 return -1;
 336             streamio->position = offset;
 337             break;
 338
 339         case ZLIB_FILEFUNC_SEEK_CUR:
 340
 341             if (streamio->readbuf_len > 0)
 342             {
 343                 if (offset <= (streamio->readbuf_len - streamio->readbuf_pos))
 344                 {
 345                     streamio->readbuf_pos += (uint32_t)offset;
 346                     return 0;
 347                 }
 348                 offset -= (streamio->readbuf_len - streamio->readbuf_pos);
 349                 streamio->position += offset;
 350             }
 351             if (streamio->writebuf_len > 0)
 352             {
 353                 if (offset <= (streamio->writebuf_len - streamio->writebuf_pos))
 354                 {
 355                     streamio->writebuf_pos += (uint32_t)offset;
 356                     return 0;
 357                 }
 358                 //offset -= (streamio->writebuf_len - streamio->writebuf_pos);
 359             }
 360
 361             if (fflush_buf(opaque, stream) < 0)
 362                 return -1;
 363
 364             break;
 365
 366         case ZLIB_FILEFUNC_SEEK_END:
 367
 368             if (streamio->writebuf_len > 0)
 369             {
 370                 streamio->writebuf_pos = streamio->writebuf_len;
 371                 return 0;
 372             }
 373             break;
 374     }
 375
 376     streamio->readbuf_len = 0;
 377     streamio->readbuf_pos = 0;
 378     streamio->writebuf_len = 0;
 379     streamio->writebuf_pos = 0;
 380     return 1;
 381 }
 382
 383 long ZCALLBACK fseek_buf_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
 384 {
 385     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 386     ourstream_t *streamio = (ourstream_t *)stream;
 387     long ret = -1;
 388     if (bufio->filefunc.zseek_file == NULL)
 389         return ret;
 390     ret = fseek_buf_internal_func(opaque, stream, offset, origin);
 391     if (ret == 1)
 392         ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, offset, origin);
 393     return ret;
 394 }
 395
 396 long ZCALLBACK fseek64_buf_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
 397 {
 398     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 399     ourstream_t *streamio = (ourstream_t *)stream;
 400     long ret = -1;
 401     if (bufio->filefunc64.zseek64_file == NULL)
 402         return ret;
 403     ret = fseek_buf_internal_func(opaque, stream, offset, origin);
 404     if (ret == 1)
 405         ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, offset, origin);
 406     return ret;
 407 }
 408
 409 int ZCALLBACK fclose_buf_func(voidpf opaque, voidpf stream)
 410 {
 411     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 412     ourstream_t *streamio = (ourstream_t *)stream;
 413     int ret = 0;
 414     fflush_buf(opaque, stream);
 415     print_buf(opaque, stream, "close\n");
 416     if (streamio->readbuf_hits + streamio->readbuf_misses > 0)
 417         print_buf(opaque, stream, "read efficency %.02f%%\n", (streamio->readbuf_hits / ((float)streamio->readbuf_hits + streamio->readbuf_misses)) * 100);
 418     if (streamio->writebuf_hits + streamio->writebuf_misses > 0)
 419         print_buf(opaque, stream, "write efficency %.02f%%\n", (streamio->writebuf_hits / ((float)streamio->writebuf_hits + streamio->writebuf_misses)) * 100);
 420     if (bufio->filefunc64.zclose_file != NULL)
 421         ret = bufio->filefunc64.zclose_file(bufio->filefunc64.opaque, streamio->stream);
 422     else
 423         ret = bufio->filefunc.zclose_file(bufio->filefunc.opaque, streamio->stream);
 424     free(streamio);
 425     return ret;
 426 }
 427
 428 int ZCALLBACK ferror_buf_func(voidpf opaque, voidpf stream)
 429 {
 430     ourbuffer_t *bufio = (ourbuffer_t *)opaque;
 431     ourstream_t *streamio = (ourstream_t *)stream;
 432     if (bufio->filefunc64.zerror_file != NULL)
 433         return bufio->filefunc64.zerror_file(bufio->filefunc64.opaque, streamio->stream);
 434     return bufio->filefunc.zerror_file(bufio->filefunc.opaque, streamio->stream);
 435 }
 436
 437 void fill_buffer_filefunc(zlib_filefunc_def *pzlib_filefunc_def, ourbuffer_t *ourbuf)
 438 {
 439     pzlib_filefunc_def->zopen_file = fopen_buf_func;
 440     pzlib_filefunc_def->zopendisk_file = fopendisk_buf_func;
 441     pzlib_filefunc_def->zread_file = fread_buf_func;
 442     pzlib_filefunc_def->zwrite_file = fwrite_buf_func;
 443     pzlib_filefunc_def->ztell_file = ftell_buf_func;
 444     pzlib_filefunc_def->zseek_file = fseek_buf_func;
 445     pzlib_filefunc_def->zclose_file = fclose_buf_func;
 446     pzlib_filefunc_def->zerror_file = ferror_buf_func;
 447     pzlib_filefunc_def->opaque = ourbuf;
 448 }
 449
 450 void fill_buffer_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def, ourbuffer_t *ourbuf)
 451 {
 452     pzlib_filefunc_def->zopen64_file = fopen64_buf_func;
 453     pzlib_filefunc_def->zopendisk64_file = fopendisk64_buf_func;
 454     pzlib_filefunc_def->zread_file = fread_buf_func;
 455     pzlib_filefunc_def->zwrite_file = fwrite_buf_func;
 456     pzlib_filefunc_def->ztell64_file = ftell64_buf_func;
 457     pzlib_filefunc_def->zseek64_file = fseek64_buf_func;
 458     pzlib_filefunc_def->zclose_file = fclose_buf_func;
 459     pzlib_filefunc_def->zerror_file = ferror_buf_func;
 460     pzlib_filefunc_def->opaque = ourbuf;
 461 }