1 /* ioapi_buf.c -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API
4 This version of ioapi is designed to buffer IO.
6 Copyright (C) 2012-2017 Nathan Moinvaziri
7 https://github.com/nmoinvaz/minizip
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.
22 #include "ioapi_buf.h"
24 #ifndef IOBUF_BUFFERSIZE
25 # define IOBUF_BUFFERSIZE (UINT16_MAX)
30 # define PRINTF _cprintf
31 # define VPRINTF _vcprintf
33 # define PRINTF printf
34 # define VPRINTF vprintf
37 //#define IOBUF_VERBOSE
42 const __typeof__(x) _x = (x); \
43 const __typeof__(y) _y = (y); \
44 (void) (&_x == &_y); \
50 const __typeof__(x) _x = (x); \
51 const __typeof__(y) _y = (y); \
52 (void) (&_x == &_y); \
57 typedef struct ourstream_s {
58 char readbuf[IOBUF_BUFFERSIZE];
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;
72 #if defined(IOBUF_VERBOSE)
73 # define print_buf(o,s,f,...) print_buf_internal(o,s,f,__VA_ARGS__);
75 # define print_buf(o,s,f,...)
78 void print_buf_internal(ZIP_UNUSED voidpf opaque, voidpf stream, char *format, ...)
80 ourstream_t *streamio = (ourstream_t *)stream;
82 PRINTF("Buf stream %p - ", streamio);
83 va_start(arglist, format);
84 VPRINTF(format, arglist);
88 voidpf fopen_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, ZIP_UNUSED uint32_t number_disk, ZIP_UNUSED int mode)
90 ourstream_t *streamio = NULL;
93 streamio = (ourstream_t *)malloc(sizeof(ourstream_t));
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);
102 voidpf ZCALLBACK fopen_buf_func(voidpf opaque, const char *filename, int mode)
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);
109 voidpf ZCALLBACK fopen64_buf_func(voidpf opaque, const void *filename, int mode)
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);
116 voidpf ZCALLBACK fopendisk_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode)
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);
124 voidpf ZCALLBACK fopendisk64_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode)
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);
132 long fflush_buf(voidpf opaque, voidpf stream)
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;
141 while (bytes_left_to_write > 0)
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);
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);
148 streamio->writebuf_misses += 1;
150 print_buf(opaque, stream, "write flush [%d:%d len %d]\n", bytes_to_write, bytes_left_to_write, streamio->writebuf_len);
152 if (bytes_written < 0)
153 return bytes_written;
155 total_bytes_to_write += bytes_written;
156 bytes_left_to_write -= bytes_written;
157 streamio->position += bytes_written;
159 streamio->writebuf_len = 0;
160 streamio->writebuf_pos = 0;
161 return total_bytes_to_write;
164 uint32_t ZCALLBACK fread_buf_func(voidpf opaque, voidpf stream, void *buf, uint32_t size)
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;
174 print_buf(opaque, stream, "read [size %ld pos %lld]\n", size, streamio->position);
176 if (streamio->writebuf_len > 0)
178 print_buf(opaque, stream, "switch from write to read, not yet supported [%lld]\n", streamio->position);
181 while (bytes_left_to_read > 0)
183 if ((streamio->readbuf_len == 0) || (streamio->readbuf_pos == streamio->readbuf_len))
185 if (streamio->readbuf_len == IOBUF_BUFFERSIZE)
187 streamio->readbuf_pos = 0;
188 streamio->readbuf_len = 0;
191 bytes_to_read = IOBUF_BUFFERSIZE - (streamio->readbuf_len - streamio->readbuf_pos);
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);
196 bytes_read = bufio->filefunc.zread_file(bufio->filefunc.opaque, streamio->stream, streamio->readbuf + streamio->readbuf_pos, bytes_to_read);
198 streamio->readbuf_misses += 1;
199 streamio->readbuf_len += bytes_read;
200 streamio->position += bytes_read;
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);
208 if ((streamio->readbuf_len - streamio->readbuf_pos) > 0)
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);
213 buf_len += bytes_to_copy;
214 bytes_left_to_read -= bytes_to_copy;
216 streamio->readbuf_hits += 1;
217 streamio->readbuf_pos += bytes_to_copy;
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);
223 return size - bytes_left_to_read;
226 uint32_t ZCALLBACK fwrite_buf_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
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;
235 print_buf(opaque, stream, "write [size %ld len %d pos %lld]\n", size, streamio->writebuf_len, streamio->position);
237 if (streamio->readbuf_len > 0)
239 streamio->position -= streamio->readbuf_len;
240 streamio->position += streamio->readbuf_pos;
242 streamio->readbuf_len = 0;
243 streamio->readbuf_pos = 0;
245 print_buf(opaque, stream, "switch from read to write [%lld]\n", streamio->position);
247 if (bufio->filefunc64.zseek64_file != NULL)
248 ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, streamio->position, ZLIB_FILEFUNC_SEEK_SET);
250 ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, (uint32_t)streamio->position, ZLIB_FILEFUNC_SEEK_SET);
256 while (bytes_left_to_write > 0)
258 bytes_to_copy = min(bytes_left_to_write, (uint32_t)(IOBUF_BUFFERSIZE - min(streamio->writebuf_len, streamio->writebuf_pos)));
260 if (bytes_to_copy == 0)
262 if (fflush_buf(opaque, stream) <= 0)
268 memcpy(streamio->writebuf + streamio->writebuf_pos, (char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
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);
272 bytes_left_to_write -= bytes_to_copy;
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;
280 return size - bytes_left_to_write;
283 uint64_t ftell_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint64_t position)
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;
295 long ZCALLBACK ftell_buf_func(voidpf opaque, voidpf stream)
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);
303 uint64_t ZCALLBACK ftell64_buf_func(voidpf opaque, voidpf stream)
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);
311 int fseek_buf_internal_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
313 ourstream_t *streamio = (ourstream_t *)stream;
315 print_buf(opaque, stream, "seek [origin %d offset %llu pos %lld]\n", origin, offset, streamio->position);
319 case ZLIB_FILEFUNC_SEEK_SET:
321 if (streamio->writebuf_len > 0)
323 if ((offset >= streamio->position) && (offset <= streamio->position + streamio->writebuf_len))
325 streamio->writebuf_pos = (uint32_t)(offset - streamio->position);
329 if ((streamio->readbuf_len > 0) && (offset < streamio->position) && (offset >= streamio->position - streamio->readbuf_len))
331 streamio->readbuf_pos = (uint32_t)(offset - (streamio->position - streamio->readbuf_len));
334 if (fflush_buf(opaque, stream) < 0)
336 streamio->position = offset;
339 case ZLIB_FILEFUNC_SEEK_CUR:
341 if (streamio->readbuf_len > 0)
343 if (offset <= (streamio->readbuf_len - streamio->readbuf_pos))
345 streamio->readbuf_pos += (uint32_t)offset;
348 offset -= (streamio->readbuf_len - streamio->readbuf_pos);
349 streamio->position += offset;
351 if (streamio->writebuf_len > 0)
353 if (offset <= (streamio->writebuf_len - streamio->writebuf_pos))
355 streamio->writebuf_pos += (uint32_t)offset;
358 //offset -= (streamio->writebuf_len - streamio->writebuf_pos);
361 if (fflush_buf(opaque, stream) < 0)
366 case ZLIB_FILEFUNC_SEEK_END:
368 if (streamio->writebuf_len > 0)
370 streamio->writebuf_pos = streamio->writebuf_len;
376 streamio->readbuf_len = 0;
377 streamio->readbuf_pos = 0;
378 streamio->writebuf_len = 0;
379 streamio->writebuf_pos = 0;
383 long ZCALLBACK fseek_buf_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
385 ourbuffer_t *bufio = (ourbuffer_t *)opaque;
386 ourstream_t *streamio = (ourstream_t *)stream;
388 if (bufio->filefunc.zseek_file == NULL)
390 ret = fseek_buf_internal_func(opaque, stream, offset, origin);
392 ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, offset, origin);
396 long ZCALLBACK fseek64_buf_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
398 ourbuffer_t *bufio = (ourbuffer_t *)opaque;
399 ourstream_t *streamio = (ourstream_t *)stream;
401 if (bufio->filefunc64.zseek64_file == NULL)
403 ret = fseek_buf_internal_func(opaque, stream, offset, origin);
405 ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, offset, origin);
409 int ZCALLBACK fclose_buf_func(voidpf opaque, voidpf stream)
411 ourbuffer_t *bufio = (ourbuffer_t *)opaque;
412 ourstream_t *streamio = (ourstream_t *)stream;
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);
423 ret = bufio->filefunc.zclose_file(bufio->filefunc.opaque, streamio->stream);
428 int ZCALLBACK ferror_buf_func(voidpf opaque, voidpf stream)
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);
437 void fill_buffer_filefunc(zlib_filefunc_def *pzlib_filefunc_def, ourbuffer_t *ourbuf)
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;
450 void fill_buffer_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def, ourbuffer_t *ourbuf)
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;