Coverage Report

Created: 2025-07-11 06:45

/src/minizip-ng/mz_strm.c
Line
Count
Source (jump to first uncovered line)
1
/* mz_strm.c -- Stream interface
2
   part of the minizip-ng project
3
4
   Copyright (C) Nathan Moinvaziri
5
     https://github.com/zlib-ng/minizip-ng
6
7
   This program is distributed under the terms of the same license as zlib.
8
   See the accompanying LICENSE file for the full text of the license.
9
*/
10
11
#include "mz.h"
12
#include "mz_strm.h"
13
14
/***************************************************************************/
15
16
0
#define MZ_STREAM_FIND_SIZE (1024)
17
18
/***************************************************************************/
19
20
696
int32_t mz_stream_open(void *stream, const char *path, int32_t mode) {
21
696
    mz_stream *strm = (mz_stream *)stream;
22
696
    if (!strm || !strm->vtbl || !strm->vtbl->open)
23
0
        return MZ_STREAM_ERROR;
24
696
    return strm->vtbl->open(strm, path, mode);
25
696
}
26
27
29.8k
int32_t mz_stream_is_open(void *stream) {
28
29.8k
    mz_stream *strm = (mz_stream *)stream;
29
29.8k
    if (!strm || !strm->vtbl || !strm->vtbl->is_open)
30
0
        return MZ_STREAM_ERROR;
31
29.8k
    return strm->vtbl->is_open(strm);
32
29.8k
}
33
34
2.66k
int32_t mz_stream_read(void *stream, void *buf, int32_t size) {
35
2.66k
    mz_stream *strm = (mz_stream *)stream;
36
2.66k
    if (!strm || !strm->vtbl || !strm->vtbl->read)
37
0
        return MZ_PARAM_ERROR;
38
2.66k
    if (mz_stream_is_open(strm) != MZ_OK)
39
0
        return MZ_STREAM_ERROR;
40
2.66k
    return strm->vtbl->read(strm, buf, size);
41
2.66k
}
42
43
2.31k
static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len) {
44
2.31k
    uint8_t buf[8];
45
2.31k
    int32_t n = 0;
46
2.31k
    int32_t i = 0;
47
48
2.31k
    *value = 0;
49
2.31k
    if (mz_stream_read(stream, buf, len) == len) {
50
4.65k
        for (n = 0; n < len; n += 1, i += 8)
51
2.54k
            *value += ((uint64_t)buf[n]) << i;
52
2.10k
    } else if (mz_stream_error(stream))
53
0
        return MZ_STREAM_ERROR;
54
212
    else
55
212
        return MZ_END_OF_STREAM;
56
57
2.10k
    return MZ_OK;
58
2.31k
}
59
60
1.85k
int32_t mz_stream_read_uint8(void *stream, uint8_t *value) {
61
1.85k
    int32_t err = MZ_OK;
62
1.85k
    uint64_t value64 = 0;
63
64
1.85k
    *value = 0;
65
1.85k
    err = mz_stream_read_value(stream, &value64, sizeof(uint8_t));
66
1.85k
    if (err == MZ_OK)
67
1.66k
        *value = (uint8_t)value64;
68
1.85k
    return err;
69
1.85k
}
70
71
463
int32_t mz_stream_read_uint16(void *stream, uint16_t *value) {
72
463
    int32_t err = MZ_OK;
73
463
    uint64_t value64 = 0;
74
75
463
    *value = 0;
76
463
    err = mz_stream_read_value(stream, &value64, sizeof(uint16_t));
77
463
    if (err == MZ_OK)
78
441
        *value = (uint16_t)value64;
79
463
    return err;
80
463
}
81
82
0
int32_t mz_stream_read_uint32(void *stream, uint32_t *value) {
83
0
    int32_t err = MZ_OK;
84
0
    uint64_t value64 = 0;
85
86
0
    *value = 0;
87
0
    err = mz_stream_read_value(stream, &value64, sizeof(uint32_t));
88
0
    if (err == MZ_OK)
89
0
        *value = (uint32_t)value64;
90
0
    return err;
91
0
}
92
93
0
int32_t mz_stream_read_int64(void *stream, int64_t *value) {
94
0
    return mz_stream_read_value(stream, (uint64_t *)value, sizeof(uint64_t));
95
0
}
96
97
0
int32_t mz_stream_read_uint64(void *stream, uint64_t *value) {
98
0
    return mz_stream_read_value(stream, value, sizeof(uint64_t));
99
0
}
100
101
21.1k
int32_t mz_stream_write(void *stream, const void *buf, int32_t size) {
102
21.1k
    mz_stream *strm = (mz_stream *)stream;
103
21.1k
    if (size == 0)
104
863
        return size;
105
20.3k
    if (!strm || !strm->vtbl || !strm->vtbl->write)
106
0
        return MZ_PARAM_ERROR;
107
20.3k
    if (mz_stream_is_open(strm) != MZ_OK)
108
0
        return MZ_STREAM_ERROR;
109
20.3k
    return strm->vtbl->write(strm, buf, size);
110
20.3k
}
111
112
17.0k
static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
113
17.0k
    mz_stream *strm = (mz_stream *)stream;
114
17.0k
    uint8_t buf[8];
115
17.0k
    int32_t n = 0;
116
117
17.0k
    if (!strm)
118
0
        return MZ_PARAM_ERROR;
119
69.9k
    for (n = 0; n < len; n += 1) {
120
52.8k
        buf[n] = (uint8_t)(value & 0xff);
121
52.8k
        value >>= 8;
122
52.8k
    }
123
124
17.0k
    if (value != 0) {
125
        /* Data overflow - hack for ZIP64 (X Roche) */
126
0
        for (n = 0; n < len; n += 1)
127
0
            buf[n] = 0xff;
128
0
    }
129
130
17.0k
    if (mz_stream_write(strm, buf, len) != len)
131
0
        return MZ_STREAM_ERROR;
132
133
17.0k
    return MZ_OK;
134
17.0k
}
135
136
1.74k
int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
137
1.74k
    return mz_stream_write_value(stream, value, sizeof(uint8_t));
138
1.74k
}
139
140
7.75k
int32_t mz_stream_write_uint16(void *stream, uint16_t value) {
141
7.75k
    return mz_stream_write_value(stream, value, sizeof(uint16_t));
142
7.75k
}
143
144
6.26k
int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
145
6.26k
    return mz_stream_write_value(stream, value, sizeof(uint32_t));
146
6.26k
}
147
148
1.31k
int32_t mz_stream_write_int64(void *stream, int64_t value) {
149
1.31k
    return mz_stream_write_value(stream, (uint64_t)value, sizeof(uint64_t));
150
1.31k
}
151
152
0
int32_t mz_stream_write_uint64(void *stream, uint64_t value) {
153
0
    return mz_stream_write_value(stream, value, sizeof(uint64_t));
154
0
}
155
156
437
int32_t mz_stream_copy(void *target, void *source, int32_t len) {
157
437
    return mz_stream_copy_stream(target, NULL, source, NULL, len);
158
437
}
159
160
0
int32_t mz_stream_copy_to_end(void *target, void *source) {
161
0
    return mz_stream_copy_stream_to_end(target, NULL, source, NULL);
162
0
}
163
164
int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb,
165
437
                              int32_t len) {
166
437
    uint8_t buf[16384];
167
437
    int32_t bytes_to_copy = 0;
168
437
    int32_t read = 0;
169
437
    int32_t written = 0;
170
171
437
    if (!write_cb)
172
437
        write_cb = mz_stream_write;
173
437
    if (!read_cb)
174
437
        read_cb = mz_stream_read;
175
176
785
    while (len > 0) {
177
348
        bytes_to_copy = len;
178
348
        if (bytes_to_copy > (int32_t)sizeof(buf))
179
0
            bytes_to_copy = sizeof(buf);
180
348
        read = read_cb(source, buf, bytes_to_copy);
181
348
        if (read <= 0)
182
0
            return MZ_STREAM_ERROR;
183
348
        written = write_cb(target, buf, read);
184
348
        if (written != read)
185
0
            return MZ_STREAM_ERROR;
186
348
        len -= read;
187
348
    }
188
189
437
    return MZ_OK;
190
437
}
191
192
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source,
193
0
                                     mz_stream_read_cb read_cb) {
194
0
    uint8_t buf[16384];
195
0
    int32_t read = 0;
196
0
    int32_t written = 0;
197
198
0
    if (!write_cb)
199
0
        write_cb = mz_stream_write;
200
0
    if (!read_cb)
201
0
        read_cb = mz_stream_read;
202
203
0
    read = read_cb(source, buf, sizeof(buf));
204
0
    while (read > 0) {
205
0
        written = write_cb(target, buf, read);
206
0
        if (written != read)
207
0
            return MZ_STREAM_ERROR;
208
0
        read = read_cb(source, buf, sizeof(buf));
209
0
    }
210
211
0
    if (read < 0)
212
0
        return MZ_STREAM_ERROR;
213
214
0
    return MZ_OK;
215
0
}
216
217
3.40k
int64_t mz_stream_tell(void *stream) {
218
3.40k
    mz_stream *strm = (mz_stream *)stream;
219
3.40k
    if (!strm || !strm->vtbl || !strm->vtbl->tell)
220
0
        return MZ_PARAM_ERROR;
221
3.40k
    if (mz_stream_is_open(strm) != MZ_OK)
222
0
        return MZ_STREAM_ERROR;
223
3.40k
    return strm->vtbl->tell(strm);
224
3.40k
}
225
226
1.31k
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
227
1.31k
    mz_stream *strm = (mz_stream *)stream;
228
1.31k
    if (!strm || !strm->vtbl || !strm->vtbl->seek)
229
0
        return MZ_PARAM_ERROR;
230
1.31k
    if (mz_stream_is_open(strm) != MZ_OK)
231
0
        return MZ_STREAM_ERROR;
232
1.31k
    if (origin == MZ_SEEK_SET && offset < 0)
233
0
        return MZ_SEEK_ERROR;
234
1.31k
    return strm->vtbl->seek(strm, offset, origin);
235
1.31k
}
236
237
0
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
238
0
    uint8_t buf[MZ_STREAM_FIND_SIZE];
239
0
    int32_t buf_pos = 0;
240
0
    int32_t read_size = sizeof(buf);
241
0
    int32_t read = 0;
242
0
    int64_t read_pos = 0;
243
0
    int64_t start_pos = 0;
244
0
    int64_t disk_pos = 0;
245
0
    int32_t i = 0;
246
0
    uint8_t first = 1;
247
0
    int32_t err = MZ_OK;
248
249
0
    if (!stream || !find || !position)
250
0
        return MZ_PARAM_ERROR;
251
0
    if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
252
0
        return MZ_PARAM_ERROR;
253
254
0
    *position = -1;
255
256
0
    start_pos = mz_stream_tell(stream);
257
258
0
    while (read_pos < max_seek) {
259
0
        if (read_size > (int32_t)(max_seek - read_pos - buf_pos) &&
260
0
            (max_seek - read_pos - buf_pos) < (int64_t)sizeof(buf)) {
261
0
            read_size = (int32_t)(max_seek - read_pos - buf_pos);
262
0
        }
263
264
0
        read = mz_stream_read(stream, buf + buf_pos, read_size);
265
0
        if ((read <= 0) || (read + buf_pos < find_size))
266
0
            break;
267
268
0
        for (i = 0; i <= read + buf_pos - find_size; i += 1) {
269
0
            if (memcmp(&buf[i], find, find_size) != 0)
270
0
                continue;
271
272
0
            disk_pos = mz_stream_tell(stream);
273
274
            /* Seek to position on disk where the data was found */
275
0
            err = mz_stream_seek(stream, disk_pos - ((int64_t)read + buf_pos - i), MZ_SEEK_SET);
276
0
            if (err != MZ_OK)
277
0
                return MZ_EXIST_ERROR;
278
279
0
            *position = start_pos + read_pos + i;
280
0
            return MZ_OK;
281
0
        }
282
283
0
        if (first) {
284
0
            read -= find_size;
285
0
            read_size -= find_size;
286
0
            buf_pos = find_size;
287
0
            first = 0;
288
0
        }
289
290
0
        memmove(buf, buf + read, find_size);
291
0
        read_pos += read;
292
0
    }
293
294
0
    return MZ_EXIST_ERROR;
295
0
}
296
297
0
int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
298
0
    uint8_t buf[MZ_STREAM_FIND_SIZE];
299
0
    int32_t buf_pos = 0;
300
0
    int32_t read_size = MZ_STREAM_FIND_SIZE;
301
0
    int64_t read_pos = 0;
302
0
    int32_t read = 0;
303
0
    int64_t start_pos = 0;
304
0
    int64_t disk_pos = 0;
305
0
    uint8_t first = 1;
306
0
    int32_t i = 0;
307
0
    int32_t err = MZ_OK;
308
309
0
    if (!stream || !find || !position)
310
0
        return MZ_PARAM_ERROR;
311
0
    if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
312
0
        return MZ_PARAM_ERROR;
313
314
0
    *position = -1;
315
316
0
    start_pos = mz_stream_tell(stream);
317
318
0
    while (read_pos < max_seek) {
319
0
        if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
320
0
            read_size = (int32_t)(max_seek - read_pos);
321
322
0
        if (mz_stream_seek(stream, start_pos - (read_pos + read_size), MZ_SEEK_SET) != MZ_OK)
323
0
            break;
324
0
        read = mz_stream_read(stream, buf, read_size);
325
0
        if ((read <= 0) || (read + buf_pos < find_size))
326
0
            break;
327
0
        if (read + buf_pos < MZ_STREAM_FIND_SIZE)
328
0
            memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);
329
330
0
        for (i = find_size; i <= (read + buf_pos); i += 1) {
331
0
            if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
332
0
                continue;
333
334
0
            disk_pos = mz_stream_tell(stream);
335
336
            /* Seek to position on disk where the data was found */
337
0
            err = mz_stream_seek(stream, disk_pos + buf_pos - i, MZ_SEEK_SET);
338
0
            if (err != MZ_OK)
339
0
                return MZ_EXIST_ERROR;
340
341
0
            *position = start_pos - (read_pos - buf_pos + i);
342
0
            return MZ_OK;
343
0
        }
344
345
0
        if (first) {
346
0
            read -= find_size;
347
0
            read_size -= find_size;
348
0
            buf_pos = find_size;
349
0
            first = 0;
350
0
        }
351
352
0
        if (read == 0)
353
0
            break;
354
355
0
        memmove(buf + read_size, buf, find_size);
356
0
        read_pos += read;
357
0
    }
358
359
0
    return MZ_EXIST_ERROR;
360
0
}
361
362
971
int32_t mz_stream_close(void *stream) {
363
971
    mz_stream *strm = (mz_stream *)stream;
364
971
    if (!strm || !strm->vtbl || !strm->vtbl->close)
365
0
        return MZ_PARAM_ERROR;
366
971
    if (mz_stream_is_open(stream) != MZ_OK)
367
0
        return MZ_STREAM_ERROR;
368
971
    return strm->vtbl->close(strm);
369
971
}
370
371
212
int32_t mz_stream_error(void *stream) {
372
212
    mz_stream *strm = (mz_stream *)stream;
373
212
    if (!strm || !strm->vtbl || !strm->vtbl->error)
374
0
        return MZ_PARAM_ERROR;
375
212
    return strm->vtbl->error(strm);
376
212
}
377
378
882
int32_t mz_stream_set_base(void *stream, void *base) {
379
882
    mz_stream *strm = (mz_stream *)stream;
380
882
    strm->base = (mz_stream *)base;
381
882
    return MZ_OK;
382
882
}
383
384
0
void *mz_stream_get_interface(void *stream) {
385
0
    mz_stream *strm = (mz_stream *)stream;
386
0
    if (!strm || !strm->vtbl)
387
0
        return NULL;
388
0
    return (void *)strm->vtbl;
389
0
}
390
391
2.19k
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
392
2.19k
    mz_stream *strm = (mz_stream *)stream;
393
2.19k
    if (!strm || !strm->vtbl || !strm->vtbl->get_prop_int64)
394
1.31k
        return MZ_PARAM_ERROR;
395
882
    return strm->vtbl->get_prop_int64(strm, prop, value);
396
2.19k
}
397
398
785
int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value) {
399
785
    mz_stream *strm = (mz_stream *)stream;
400
785
    if (!strm || !strm->vtbl || !strm->vtbl->set_prop_int64)
401
437
        return MZ_PARAM_ERROR;
402
348
    return strm->vtbl->set_prop_int64(strm, prop, value);
403
785
}
404
405
0
void *mz_stream_create(mz_stream_vtbl *vtbl) {
406
0
    if (!vtbl || !vtbl->create)
407
0
        return NULL;
408
0
    return vtbl->create();
409
0
}
410
411
1.13k
void mz_stream_delete(void **stream) {
412
1.13k
    mz_stream *strm = NULL;
413
1.13k
    if (!stream)
414
0
        return;
415
1.13k
    strm = (mz_stream *)*stream;
416
1.13k
    if (strm && strm->vtbl && strm->vtbl->destroy)
417
1.13k
        strm->vtbl->destroy(stream);
418
1.13k
    *stream = NULL;
419
1.13k
}
420
421
/***************************************************************************/
422
423
typedef struct mz_stream_raw_s {
424
    mz_stream stream;
425
    int64_t total_in;
426
    int64_t total_out;
427
    int64_t max_total_in;
428
} mz_stream_raw;
429
430
/***************************************************************************/
431
432
510
int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode) {
433
510
    MZ_UNUSED(stream);
434
510
    MZ_UNUSED(path);
435
510
    MZ_UNUSED(mode);
436
437
510
    return MZ_OK;
438
510
}
439
440
962
int32_t mz_stream_raw_is_open(void *stream) {
441
962
    mz_stream_raw *raw = (mz_stream_raw *)stream;
442
962
    return mz_stream_is_open(raw->stream.base);
443
962
}
444
445
0
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size) {
446
0
    mz_stream_raw *raw = (mz_stream_raw *)stream;
447
0
    int32_t bytes_to_read = size;
448
0
    int32_t read = 0;
449
450
0
    if (raw->max_total_in > 0) {
451
0
        if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
452
0
            bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
453
0
    }
454
455
0
    read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
456
457
0
    if (read > 0) {
458
0
        raw->total_in += read;
459
0
        raw->total_out += read;
460
0
    }
461
462
0
    return read;
463
0
}
464
465
361
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size) {
466
361
    mz_stream_raw *raw = (mz_stream_raw *)stream;
467
361
    int32_t written = 0;
468
469
361
    written = mz_stream_write(raw->stream.base, buf, size);
470
471
361
    if (written > 0) {
472
361
        raw->total_out += written;
473
361
        raw->total_in += written;
474
361
    }
475
476
361
    return written;
477
361
}
478
479
0
int64_t mz_stream_raw_tell(void *stream) {
480
0
    mz_stream_raw *raw = (mz_stream_raw *)stream;
481
0
    return mz_stream_tell(raw->stream.base);
482
0
}
483
484
0
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin) {
485
0
    mz_stream_raw *raw = (mz_stream_raw *)stream;
486
0
    return mz_stream_seek(raw->stream.base, offset, origin);
487
0
}
488
489
348
int32_t mz_stream_raw_close(void *stream) {
490
348
    MZ_UNUSED(stream);
491
348
    return MZ_OK;
492
348
}
493
494
0
int32_t mz_stream_raw_error(void *stream) {
495
0
    mz_stream_raw *raw = (mz_stream_raw *)stream;
496
0
    return mz_stream_error(raw->stream.base);
497
0
}
498
499
696
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
500
696
    mz_stream_raw *raw = (mz_stream_raw *)stream;
501
696
    switch (prop) {
502
348
    case MZ_STREAM_PROP_TOTAL_IN:
503
348
        *value = raw->total_in;
504
348
        return MZ_OK;
505
348
    case MZ_STREAM_PROP_TOTAL_OUT:
506
348
        *value = raw->total_out;
507
348
        return MZ_OK;
508
696
    }
509
0
    return MZ_EXIST_ERROR;
510
696
}
511
512
348
int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value) {
513
348
    mz_stream_raw *raw = (mz_stream_raw *)stream;
514
348
    switch (prop) {
515
0
    case MZ_STREAM_PROP_TOTAL_IN_MAX:
516
0
        raw->max_total_in = value;
517
0
        return MZ_OK;
518
348
    }
519
348
    return MZ_EXIST_ERROR;
520
348
}
521
522
/***************************************************************************/
523
524
static mz_stream_vtbl mz_stream_raw_vtbl = {
525
    mz_stream_raw_open,   mz_stream_raw_is_open, mz_stream_raw_read,           mz_stream_raw_write,
526
    mz_stream_raw_tell,   mz_stream_raw_seek,    mz_stream_raw_close,          mz_stream_raw_error,
527
    mz_stream_raw_create, mz_stream_raw_delete,  mz_stream_raw_get_prop_int64, mz_stream_raw_set_prop_int64};
528
529
/***************************************************************************/
530
531
510
void *mz_stream_raw_create(void) {
532
510
    mz_stream_raw *raw = (mz_stream_raw *)calloc(1, sizeof(mz_stream_raw));
533
510
    if (raw)
534
510
        raw->stream.vtbl = &mz_stream_raw_vtbl;
535
510
    return raw;
536
510
}
537
538
510
void mz_stream_raw_delete(void **stream) {
539
510
    mz_stream_raw *raw = NULL;
540
510
    if (!stream)
541
0
        return;
542
510
    raw = (mz_stream_raw *)*stream;
543
510
    free(raw);
544
510
    *stream = NULL;
545
510
}