/src/minizip-ng/mz_strm.c

Source (jump to first uncovered line)
/* mz_strm.c -- Stream interface
   part of the minizip-ng project

   Copyright (C) Nathan Moinvaziri
     https://github.com/zlib-ng/minizip-ng

   This program is distributed under the terms of the same license as zlib.
   See the accompanying LICENSE file for the full text of the license.
*/

#include "mz.h"
#include "mz_strm.h"

/***************************************************************************/

#define MZ_STREAM_FIND_SIZE (1024)

/***************************************************************************/

int32_t mz_stream_open(void *stream, const char *path, int32_t mode) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->open)
        return MZ_STREAM_ERROR;
    return strm->vtbl->open(strm, path, mode);
}

int32_t mz_stream_is_open(void *stream) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->is_open)
        return MZ_STREAM_ERROR;
    return strm->vtbl->is_open(strm);
}

int32_t mz_stream_read(void *stream, void *buf, int32_t size) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->read)
        return MZ_PARAM_ERROR;
    if (mz_stream_is_open(strm) != MZ_OK)
        return MZ_STREAM_ERROR;
    return strm->vtbl->read(strm, buf, size);
}

static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len) {
    uint8_t buf[8];
    int32_t n = 0;
    int32_t i = 0;

    *value = 0;
    if (mz_stream_read(stream, buf, len) == len) {
        for (n = 0; n < len; n += 1, i += 8)
            *value += ((uint64_t)buf[n]) << i;
    } else if (mz_stream_error(stream))
        return MZ_STREAM_ERROR;
    else
        return MZ_END_OF_STREAM;

    return MZ_OK;
}

int32_t mz_stream_read_uint8(void *stream, uint8_t *value) {
    int32_t err = MZ_OK;
    uint64_t value64 = 0;

    *value = 0;
    err = mz_stream_read_value(stream, &value64, sizeof(uint8_t));
    if (err == MZ_OK)
        *value = (uint8_t)value64;
    return err;
}

int32_t mz_stream_read_uint16(void *stream, uint16_t *value) {
    int32_t err = MZ_OK;
    uint64_t value64 = 0;

    *value = 0;
    err = mz_stream_read_value(stream, &value64, sizeof(uint16_t));
    if (err == MZ_OK)
        *value = (uint16_t)value64;
    return err;
}

int32_t mz_stream_read_uint32(void *stream, uint32_t *value) {
    int32_t err = MZ_OK;
    uint64_t value64 = 0;

    *value = 0;
    err = mz_stream_read_value(stream, &value64, sizeof(uint32_t));
    if (err == MZ_OK)
        *value = (uint32_t)value64;
    return err;
}

int32_t mz_stream_read_int64(void *stream, int64_t *value) {
    return mz_stream_read_value(stream, (uint64_t *)value, sizeof(uint64_t));
}

int32_t mz_stream_read_uint64(void *stream, uint64_t *value) {
    return mz_stream_read_value(stream, value, sizeof(uint64_t));
}

int32_t mz_stream_write(void *stream, const void *buf, int32_t size) {
    mz_stream *strm = (mz_stream *)stream;
    if (size == 0)
        return size;
    if (!strm || !strm->vtbl || !strm->vtbl->write)
        return MZ_PARAM_ERROR;
    if (mz_stream_is_open(strm) != MZ_OK)
        return MZ_STREAM_ERROR;
    return strm->vtbl->write(strm, buf, size);
}

static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
    mz_stream *strm = (mz_stream *)stream;
    uint8_t buf[8];
    int32_t n = 0;

    if (!strm)
        return MZ_PARAM_ERROR;
    for (n = 0; n < len; n += 1) {
        buf[n] = (uint8_t)(value & 0xff);
        value >>= 8;
    }

    if (value != 0) {
        /* Data overflow - hack for ZIP64 (X Roche) */
        for (n = 0; n < len; n += 1)
            buf[n] = 0xff;
    }

    if (mz_stream_write(strm, buf, len) != len)
        return MZ_STREAM_ERROR;

    return MZ_OK;
}

int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
    return mz_stream_write_value(stream, value, sizeof(uint8_t));
}

int32_t mz_stream_write_uint16(void *stream, uint16_t value) {
    return mz_stream_write_value(stream, value, sizeof(uint16_t));
}

int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
    return mz_stream_write_value(stream, value, sizeof(uint32_t));
}

int32_t mz_stream_write_int64(void *stream, int64_t value) {
    return mz_stream_write_value(stream, (uint64_t)value, sizeof(uint64_t));
}

int32_t mz_stream_write_uint64(void *stream, uint64_t value) {
    return mz_stream_write_value(stream, value, sizeof(uint64_t));
}

int32_t mz_stream_copy(void *target, void *source, int32_t len) {
    return mz_stream_copy_stream(target, NULL, source, NULL, len);
}

int32_t mz_stream_copy_to_end(void *target, void *source) {
    return mz_stream_copy_stream_to_end(target, NULL, source, NULL);
}

int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb,
                              int32_t len) {
    uint8_t buf[16384];
    int32_t bytes_to_copy = 0;
    int32_t read = 0;
    int32_t written = 0;

    if (!write_cb)
        write_cb = mz_stream_write;
    if (!read_cb)
        read_cb = mz_stream_read;

    while (len > 0) {
        bytes_to_copy = len;
        if (bytes_to_copy > (int32_t)sizeof(buf))
            bytes_to_copy = sizeof(buf);
        read = read_cb(source, buf, bytes_to_copy);
        if (read <= 0)
            return MZ_STREAM_ERROR;
        written = write_cb(target, buf, read);
        if (written != read)
            return MZ_STREAM_ERROR;
        len -= read;
    }

    return MZ_OK;
}

int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source,
                                     mz_stream_read_cb read_cb) {
    uint8_t buf[16384];
    int32_t read = 0;
    int32_t written = 0;

    if (!write_cb)
        write_cb = mz_stream_write;
    if (!read_cb)
        read_cb = mz_stream_read;

    read = read_cb(source, buf, sizeof(buf));
    while (read > 0) {
        written = write_cb(target, buf, read);
        if (written != read)
            return MZ_STREAM_ERROR;
        read = read_cb(source, buf, sizeof(buf));
    }

    if (read < 0)
        return MZ_STREAM_ERROR;

    return MZ_OK;
}

int64_t mz_stream_tell(void *stream) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->tell)
        return MZ_PARAM_ERROR;
    if (mz_stream_is_open(strm) != MZ_OK)
        return MZ_STREAM_ERROR;
    return strm->vtbl->tell(strm);
}

int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->seek)
        return MZ_PARAM_ERROR;
    if (mz_stream_is_open(strm) != MZ_OK)
        return MZ_STREAM_ERROR;
    if (origin == MZ_SEEK_SET && offset < 0)
        return MZ_SEEK_ERROR;
    return strm->vtbl->seek(strm, offset, origin);
}

int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
    uint8_t buf[MZ_STREAM_FIND_SIZE];
    int32_t buf_pos = 0;
    int32_t read_size = sizeof(buf);
    int32_t read = 0;
    int64_t read_pos = 0;
    int64_t start_pos = 0;
    int64_t disk_pos = 0;
    int32_t i = 0;
    uint8_t first = 1;
    int32_t err = MZ_OK;

    if (!stream || !find || !position)
        return MZ_PARAM_ERROR;
    if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
        return MZ_PARAM_ERROR;

    *position = -1;

    start_pos = mz_stream_tell(stream);

    while (read_pos < max_seek) {
        if (read_size > (int32_t)(max_seek - read_pos - buf_pos) &&
            (max_seek - read_pos - buf_pos) < (int64_t)sizeof(buf)) {
            read_size = (int32_t)(max_seek - read_pos - buf_pos);
        }

        read = mz_stream_read(stream, buf + buf_pos, read_size);
        if ((read <= 0) || (read + buf_pos < find_size))
            break;

        for (i = 0; i <= read + buf_pos - find_size; i += 1) {
            if (memcmp(&buf[i], find, find_size) != 0)
                continue;

            disk_pos = mz_stream_tell(stream);

            /* Seek to position on disk where the data was found */
            err = mz_stream_seek(stream, disk_pos - ((int64_t)read + buf_pos - i), MZ_SEEK_SET);
            if (err != MZ_OK)
                return MZ_EXIST_ERROR;

            *position = start_pos + read_pos + i;
            return MZ_OK;
        }

        if (first) {
            read -= find_size;
            read_size -= find_size;
            buf_pos = find_size;
            first = 0;
        }

        memmove(buf, buf + read, find_size);
        read_pos += read;
    }

    return MZ_EXIST_ERROR;
}

int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
    uint8_t buf[MZ_STREAM_FIND_SIZE];
    int32_t buf_pos = 0;
    int32_t read_size = MZ_STREAM_FIND_SIZE;
    int64_t read_pos = 0;
    int32_t read = 0;
    int64_t start_pos = 0;
    int64_t disk_pos = 0;
    uint8_t first = 1;
    int32_t i = 0;
    int32_t err = MZ_OK;

    if (!stream || !find || !position)
        return MZ_PARAM_ERROR;
    if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
        return MZ_PARAM_ERROR;

    *position = -1;

    start_pos = mz_stream_tell(stream);

    while (read_pos < max_seek) {
        if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
            read_size = (int32_t)(max_seek - read_pos);

        if (mz_stream_seek(stream, start_pos - (read_pos + read_size), MZ_SEEK_SET) != MZ_OK)
            break;
        read = mz_stream_read(stream, buf, read_size);
        if ((read <= 0) || (read + buf_pos < find_size))
            break;
        if (read + buf_pos < MZ_STREAM_FIND_SIZE)
            memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);

        for (i = find_size; i <= (read + buf_pos); i += 1) {
            if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
                continue;

            disk_pos = mz_stream_tell(stream);

            /* Seek to position on disk where the data was found */
            err = mz_stream_seek(stream, disk_pos + buf_pos - i, MZ_SEEK_SET);
            if (err != MZ_OK)
                return MZ_EXIST_ERROR;

            *position = start_pos - (read_pos - buf_pos + i);
            return MZ_OK;
        }

        if (first) {
            read -= find_size;
            read_size -= find_size;
            buf_pos = find_size;
            first = 0;
        }

        if (read == 0)
            break;

        memmove(buf + read_size, buf, find_size);
        read_pos += read;
    }

    return MZ_EXIST_ERROR;
}

int32_t mz_stream_close(void *stream) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->close)
        return MZ_PARAM_ERROR;
    if (mz_stream_is_open(stream) != MZ_OK)
        return MZ_STREAM_ERROR;
    return strm->vtbl->close(strm);
}

int32_t mz_stream_error(void *stream) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->error)
        return MZ_PARAM_ERROR;
    return strm->vtbl->error(strm);
}

int32_t mz_stream_set_base(void *stream, void *base) {
    mz_stream *strm = (mz_stream *)stream;
    strm->base = (mz_stream *)base;
    return MZ_OK;
}

void *mz_stream_get_interface(void *stream) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl)
        return NULL;
    return (void *)strm->vtbl;
}

int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->get_prop_int64)
        return MZ_PARAM_ERROR;
    return strm->vtbl->get_prop_int64(strm, prop, value);
}

int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value) {
    mz_stream *strm = (mz_stream *)stream;
    if (!strm || !strm->vtbl || !strm->vtbl->set_prop_int64)
        return MZ_PARAM_ERROR;
    return strm->vtbl->set_prop_int64(strm, prop, value);
}

void *mz_stream_create(mz_stream_vtbl *vtbl) {
    if (!vtbl || !vtbl->create)
        return NULL;
    return vtbl->create();
}

void mz_stream_delete(void **stream) {
    mz_stream *strm = NULL;
    if (!stream)
        return;
    strm = (mz_stream *)*stream;
    if (strm && strm->vtbl && strm->vtbl->destroy)
        strm->vtbl->destroy(stream);
    *stream = NULL;
}

/***************************************************************************/

typedef struct mz_stream_raw_s {
    mz_stream stream;
    int64_t total_in;
    int64_t total_out;
    int64_t max_total_in;
} mz_stream_raw;

/***************************************************************************/

int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode) {
    MZ_UNUSED(stream);
    MZ_UNUSED(path);
    MZ_UNUSED(mode);

    return MZ_OK;
}

int32_t mz_stream_raw_is_open(void *stream) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    return mz_stream_is_open(raw->stream.base);
}

int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    int32_t bytes_to_read = size;
    int32_t read = 0;

    if (raw->max_total_in > 0) {
        if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
            bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
    }

    read = mz_stream_read(raw->stream.base, buf, bytes_to_read);

    if (read > 0) {
        raw->total_in += read;
        raw->total_out += read;
    }

    return read;
}

int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    int32_t written = 0;

    written = mz_stream_write(raw->stream.base, buf, size);

    if (written > 0) {
        raw->total_out += written;
        raw->total_in += written;
    }

    return written;
}

int64_t mz_stream_raw_tell(void *stream) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    return mz_stream_tell(raw->stream.base);
}

int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    return mz_stream_seek(raw->stream.base, offset, origin);
}

int32_t mz_stream_raw_close(void *stream) {
    MZ_UNUSED(stream);
    return MZ_OK;
}

int32_t mz_stream_raw_error(void *stream) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    return mz_stream_error(raw->stream.base);
}

int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    switch (prop) {
    case MZ_STREAM_PROP_TOTAL_IN:
        *value = raw->total_in;
        return MZ_OK;
    case MZ_STREAM_PROP_TOTAL_OUT:
        *value = raw->total_out;
        return MZ_OK;
    }
    return MZ_EXIST_ERROR;
}

int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value) {
    mz_stream_raw *raw = (mz_stream_raw *)stream;
    switch (prop) {
    case MZ_STREAM_PROP_TOTAL_IN_MAX:
        raw->max_total_in = value;
        return MZ_OK;
    }
    return MZ_EXIST_ERROR;
}

/***************************************************************************/

static mz_stream_vtbl mz_stream_raw_vtbl = {
    mz_stream_raw_open,   mz_stream_raw_is_open, mz_stream_raw_read,           mz_stream_raw_write,
    mz_stream_raw_tell,   mz_stream_raw_seek,    mz_stream_raw_close,          mz_stream_raw_error,
    mz_stream_raw_create, mz_stream_raw_delete,  mz_stream_raw_get_prop_int64, mz_stream_raw_set_prop_int64};

/***************************************************************************/

void *mz_stream_raw_create(void) {
    mz_stream_raw *raw = (mz_stream_raw *)calloc(1, sizeof(mz_stream_raw));
    if (raw)
        raw->stream.vtbl = &mz_stream_raw_vtbl;
    return raw;
}

void mz_stream_raw_delete(void **stream) {
    mz_stream_raw *raw = NULL;
    if (!stream)
        return;
    raw = (mz_stream_raw *)*stream;
    free(raw);
    *stream = NULL;
}

Coverage Report

Created: 2025-08-28 06:22

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	24.5M	#define MZ_STREAM_FIND_SIZE (1024)
17
18		/***************************************************************************/
19
20	47.8k	int32_t mz_stream_open(void stream, const char path, int32_t mode) {
21	47.8k	mz_stream strm = (mz_stream )stream;
22	47.8k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->open)
23	0	return MZ_STREAM_ERROR;
24	47.8k	return strm->vtbl->open(strm, path, mode);
25	47.8k	}
26
27	15.4M	int32_t mz_stream_is_open(void *stream) {
28	15.4M	mz_stream strm = (mz_stream )stream;
29	15.4M	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->is_open)
30	0	return MZ_STREAM_ERROR;
31	15.4M	return strm->vtbl->is_open(strm);
32	15.4M	}
33
34	7.59M	int32_t mz_stream_read(void stream, void buf, int32_t size) {
35	7.59M	mz_stream strm = (mz_stream )stream;
36	7.59M	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->read)
37	0	return MZ_PARAM_ERROR;
38	7.59M	if (mz_stream_is_open(strm) != MZ_OK)
39	0	return MZ_STREAM_ERROR;
40	7.59M	return strm->vtbl->read(strm, buf, size);
41	7.59M	}
42
43	6.78M	static int32_t mz_stream_read_value(void stream, uint64_t value, int32_t len) {
44	6.78M	uint8_t buf[8];
45	6.78M	int32_t n = 0;
46	6.78M	int32_t i = 0;
47
48	6.78M	*value = 0;
49	6.78M	if (mz_stream_read(stream, buf, len) == len) {
50	25.8M	for (n = 0; n < len; n += 1, i += 8)
51	19.1M	*value += ((uint64_t)buf[n]) << i;
52	6.75M	} else if (mz_stream_error(stream))
53	0	return MZ_STREAM_ERROR;
54	24.1k	else
55	24.1k	return MZ_END_OF_STREAM;
56
57	6.75M	return MZ_OK;
58	6.78M	}
59
60	247k	int32_t mz_stream_read_uint8(void stream, uint8_t value) {
61	247k	int32_t err = MZ_OK;
62	247k	uint64_t value64 = 0;
63
64	247k	*value = 0;
65	247k	err = mz_stream_read_value(stream, &value64, sizeof(uint8_t));
66	247k	if (err == MZ_OK)
67	247k	*value = (uint8_t)value64;
68	247k	return err;
69	247k	}
70
71	3.87M	int32_t mz_stream_read_uint16(void stream, uint16_t value) {
72	3.87M	int32_t err = MZ_OK;
73	3.87M	uint64_t value64 = 0;
74
75	3.87M	*value = 0;
76	3.87M	err = mz_stream_read_value(stream, &value64, sizeof(uint16_t));
77	3.87M	if (err == MZ_OK)
78	3.86M	*value = (uint16_t)value64;
79	3.87M	return err;
80	3.87M	}
81
82	2.51M	int32_t mz_stream_read_uint32(void stream, uint32_t value) {
83	2.51M	int32_t err = MZ_OK;
84	2.51M	uint64_t value64 = 0;
85
86	2.51M	*value = 0;
87	2.51M	err = mz_stream_read_value(stream, &value64, sizeof(uint32_t));
88	2.51M	if (err == MZ_OK)
89	2.50M	*value = (uint32_t)value64;
90	2.51M	return err;
91	2.51M	}
92
93	71.2k	int32_t mz_stream_read_int64(void stream, int64_t value) {
94	71.2k	return mz_stream_read_value(stream, (uint64_t *)value, sizeof(uint64_t));
95	71.2k	}
96
97	67.1k	int32_t mz_stream_read_uint64(void stream, uint64_t value) {
98	67.1k	return mz_stream_read_value(stream, value, sizeof(uint64_t));
99	67.1k	}
100
101	4.33M	int32_t mz_stream_write(void stream, const void buf, int32_t size) {
102	4.33M	mz_stream strm = (mz_stream )stream;
103	4.33M	if (size == 0)
104	120k	return size;
105	4.21M	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->write)
106	0	return MZ_PARAM_ERROR;
107	4.21M	if (mz_stream_is_open(strm) != MZ_OK)
108	0	return MZ_STREAM_ERROR;
109	4.21M	return strm->vtbl->write(strm, buf, size);
110	4.21M	}
111
112	3.79M	static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
113	3.79M	mz_stream strm = (mz_stream )stream;
114	3.79M	uint8_t buf[8];
115	3.79M	int32_t n = 0;
116
117	3.79M	if (!strm)
118	0	return MZ_PARAM_ERROR;
119	11.9M	for (n = 0; n < len; n += 1) {
120	8.13M	buf[n] = (uint8_t)(value & 0xff);
121	8.13M	value >>= 8;
122	8.13M	}
123
124	3.79M	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	3.79M	if (mz_stream_write(strm, buf, len) != len)
131	0	return MZ_STREAM_ERROR;
132
133	3.79M	return MZ_OK;
134	3.79M	}
135
136	1.60M	int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
137	1.60M	return mz_stream_write_value(stream, value, sizeof(uint8_t));
138	1.60M	}
139
140	1.24M	int32_t mz_stream_write_uint16(void *stream, uint16_t value) {
141	1.24M	return mz_stream_write_value(stream, value, sizeof(uint16_t));
142	1.24M	}
143
144	887k	int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
145	887k	return mz_stream_write_value(stream, value, sizeof(uint32_t));
146	887k	}
147
148	56.9k	int32_t mz_stream_write_int64(void *stream, int64_t value) {
149	56.9k	return mz_stream_write_value(stream, (uint64_t)value, sizeof(uint64_t));
150	56.9k	}
151
152	4.08k	int32_t mz_stream_write_uint64(void *stream, uint64_t value) {
153	4.08k	return mz_stream_write_value(stream, value, sizeof(uint64_t));
154	4.08k	}
155
156	340k	int32_t mz_stream_copy(void target, void source, int32_t len) {
157	340k	return mz_stream_copy_stream(target, NULL, source, NULL, len);
158	340k	}
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	340k	int32_t len) {
166	340k	uint8_t buf[16384];
167	340k	int32_t bytes_to_copy = 0;
168	340k	int32_t read = 0;
169	340k	int32_t written = 0;
170
171	340k	if (!write_cb)
172	340k	write_cb = mz_stream_write;
173	340k	if (!read_cb)
174	340k	read_cb = mz_stream_read;
175
176	670k	while (len > 0) {
177	337k	bytes_to_copy = len;
178	337k	if (bytes_to_copy > (int32_t)sizeof(buf))
179	8.63k	bytes_to_copy = sizeof(buf);
180	337k	read = read_cb(source, buf, bytes_to_copy);
181	337k	if (read <= 0)
182	7.69k	return MZ_STREAM_ERROR;
183	329k	written = write_cb(target, buf, read);
184	329k	if (written != read)
185	0	return MZ_STREAM_ERROR;
186	329k	len -= read;
187	329k	}
188
189	332k	return MZ_OK;
190	340k	}
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	1.94M	int64_t mz_stream_tell(void *stream) {
218	1.94M	mz_stream strm = (mz_stream )stream;
219	1.94M	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->tell)
220	0	return MZ_PARAM_ERROR;
221	1.94M	if (mz_stream_is_open(strm) != MZ_OK)
222	0	return MZ_STREAM_ERROR;
223	1.94M	return strm->vtbl->tell(strm);
224	1.94M	}
225
226	1.56M	int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
227	1.56M	mz_stream strm = (mz_stream )stream;
228	1.56M	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->seek)
229	0	return MZ_PARAM_ERROR;
230	1.56M	if (mz_stream_is_open(strm) != MZ_OK)
231	0	return MZ_STREAM_ERROR;
232	1.56M	if (origin == MZ_SEEK_SET && offset < 0)
233	524	return MZ_SEEK_ERROR;
234	1.56M	return strm->vtbl->seek(strm, offset, origin);
235	1.56M	}
236
237	192k	int32_t mz_stream_find(void stream, const void find, int32_t find_size, int64_t max_seek, int64_t *position) {
238	192k	uint8_t buf[MZ_STREAM_FIND_SIZE];
239	192k	int32_t buf_pos = 0;
240	192k	int32_t read_size = sizeof(buf);
241	192k	int32_t read = 0;
242	192k	int64_t read_pos = 0;
243	192k	int64_t start_pos = 0;
244	192k	int64_t disk_pos = 0;
245	192k	int32_t i = 0;
246	192k	uint8_t first = 1;
247	192k	int32_t err = MZ_OK;
248
249	192k	if (!stream \|\| !find \|\| !position)
250	0	return MZ_PARAM_ERROR;
251	192k	if (find_size < 0 \|\| find_size >= (int32_t)sizeof(buf))
252	0	return MZ_PARAM_ERROR;
253
254	192k	*position = -1;
255
256	192k	start_pos = mz_stream_tell(stream);
257
258	206k	while (read_pos < max_seek) {
259	206k	if (read_size > (int32_t)(max_seek - read_pos - buf_pos) &&
260	206k	(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	206k	read = mz_stream_read(stream, buf + buf_pos, read_size);
265	206k	if ((read <= 0) \|\| (read + buf_pos < find_size))
266	1.02k	break;
267
268	17.3M	for (i = 0; i <= read + buf_pos - find_size; i += 1) {
269	17.3M	if (memcmp(&buf[i], find, find_size) != 0)
270	17.1M	continue;
271
272	191k	disk_pos = mz_stream_tell(stream);
273
274		/* Seek to position on disk where the data was found */
275	191k	err = mz_stream_seek(stream, disk_pos - ((int64_t)read + buf_pos - i), MZ_SEEK_SET);
276	191k	if (err != MZ_OK)
277	0	return MZ_EXIST_ERROR;
278
279	191k	*position = start_pos + read_pos + i;
280	191k	return MZ_OK;
281	191k	}
282
283	14.1k	if (first) {
284	1.29k	read -= find_size;
285	1.29k	read_size -= find_size;
286	1.29k	buf_pos = find_size;
287	1.29k	first = 0;
288	1.29k	}
289
290	14.1k	memmove(buf, buf + read, find_size);
291	14.1k	read_pos += read;
292	14.1k	}
293
294	1.02k	return MZ_EXIST_ERROR;
295	192k	}
296
297	81.2k	int32_t mz_stream_find_reverse(void stream, const void find, int32_t find_size, int64_t max_seek, int64_t *position) {
298	81.2k	uint8_t buf[MZ_STREAM_FIND_SIZE];
299	81.2k	int32_t buf_pos = 0;
300	81.2k	int32_t read_size = MZ_STREAM_FIND_SIZE;
301	81.2k	int64_t read_pos = 0;
302	81.2k	int32_t read = 0;
303	81.2k	int64_t start_pos = 0;
304	81.2k	int64_t disk_pos = 0;
305	81.2k	uint8_t first = 1;
306	81.2k	int32_t i = 0;
307	81.2k	int32_t err = MZ_OK;
308
309	81.2k	if (!stream \|\| !find \|\| !position)
310	0	return MZ_PARAM_ERROR;
311	81.2k	if (find_size < 0 \|\| find_size >= (int32_t)sizeof(buf))
312	0	return MZ_PARAM_ERROR;
313
314	81.2k	*position = -1;
315
316	81.2k	start_pos = mz_stream_tell(stream);
317
318	236k	while (read_pos < max_seek) {
319	169k	if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
320	147k	read_size = (int32_t)(max_seek - read_pos);
321
322	169k	if (mz_stream_seek(stream, start_pos - (read_pos + read_size), MZ_SEEK_SET) != MZ_OK)
323	0	break;
324	169k	read = mz_stream_read(stream, buf, read_size);
325	169k	if ((read <= 0) \|\| (read + buf_pos < find_size))
326	3	break;
327	169k	if (read + buf_pos < MZ_STREAM_FIND_SIZE)
328	147k	memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);
329
330	24.2M	for (i = find_size; i <= (read + buf_pos); i += 1) {
331	24.1M	if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
332	24.1M	continue;
333
334	14.6k	disk_pos = mz_stream_tell(stream);
335
336		/* Seek to position on disk where the data was found */
337	14.6k	err = mz_stream_seek(stream, disk_pos + buf_pos - i, MZ_SEEK_SET);
338	14.6k	if (err != MZ_OK)
339	0	return MZ_EXIST_ERROR;
340
341	14.6k	*position = start_pos - (read_pos - buf_pos + i);
342	14.6k	return MZ_OK;
343	14.6k	}
344
345	154k	if (first) {
346	67.1k	read -= find_size;
347	67.1k	read_size -= find_size;
348	67.1k	buf_pos = find_size;
349	67.1k	first = 0;
350	67.1k	}
351
352	154k	if (read == 0)
353	32	break;
354
355	154k	memmove(buf + read_size, buf, find_size);
356	154k	read_pos += read;
357	154k	}
358
359	66.5k	return MZ_EXIST_ERROR;
360	81.2k	}
361
362	28.0k	int32_t mz_stream_close(void *stream) {
363	28.0k	mz_stream strm = (mz_stream )stream;
364	28.0k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->close)
365	0	return MZ_PARAM_ERROR;
366	28.0k	if (mz_stream_is_open(stream) != MZ_OK)
367	3.13k	return MZ_STREAM_ERROR;
368	24.8k	return strm->vtbl->close(strm);
369	28.0k	}
370
371	24.1k	int32_t mz_stream_error(void *stream) {
372	24.1k	mz_stream strm = (mz_stream )stream;
373	24.1k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->error)
374	0	return MZ_PARAM_ERROR;
375	24.1k	return strm->vtbl->error(strm);
376	24.1k	}
377
378	47.8k	int32_t mz_stream_set_base(void stream, void base) {
379	47.8k	mz_stream strm = (mz_stream )stream;
380	47.8k	strm->base = (mz_stream *)base;
381	47.8k	return MZ_OK;
382	47.8k	}
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	206k	int32_t mz_stream_get_prop_int64(void stream, int32_t prop, int64_t value) {
392	206k	mz_stream strm = (mz_stream )stream;
393	206k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->get_prop_int64)
394	134k	return MZ_PARAM_ERROR;
395	71.5k	return strm->vtbl->get_prop_int64(strm, prop, value);
396	206k	}
397
398	323k	int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value) {
399	323k	mz_stream strm = (mz_stream )stream;
400	323k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->set_prop_int64)
401	275k	return MZ_PARAM_ERROR;
402	47.6k	return strm->vtbl->set_prop_int64(strm, prop, value);
403	323k	}
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	52.0k	void mz_stream_delete(void **stream) {
412	52.0k	mz_stream *strm = NULL;
413	52.0k	if (!stream)
414	0	return;
415	52.0k	strm = (mz_stream )stream;
416	52.0k	if (strm && strm->vtbl && strm->vtbl->destroy)
417	52.0k	strm->vtbl->destroy(stream);
418	52.0k	*stream = NULL;
419	52.0k	}
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	31.1k	int32_t mz_stream_raw_open(void stream, const char path, int32_t mode) {
433	31.1k	MZ_UNUSED(stream);
434	31.1k	MZ_UNUSED(path);
435	31.1k	MZ_UNUSED(mode);
436
437	31.1k	return MZ_OK;
438	31.1k	}
439
440	66.7k	int32_t mz_stream_raw_is_open(void *stream) {
441	66.7k	mz_stream_raw raw = (mz_stream_raw )stream;
442	66.7k	return mz_stream_is_open(raw->stream.base);
443	66.7k	}
444
445	28.9k	int32_t mz_stream_raw_read(void stream, void buf, int32_t size) {
446	28.9k	mz_stream_raw raw = (mz_stream_raw )stream;
447	28.9k	int32_t bytes_to_read = size;
448	28.9k	int32_t read = 0;
449
450	28.9k	if (raw->max_total_in > 0) {
451	22.1k	if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
452	2.81k	bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
453	22.1k	}
454
455	28.9k	read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
456
457	28.9k	if (read > 0) {
458	21.7k	raw->total_in += read;
459	21.7k	raw->total_out += read;
460	21.7k	}
461
462	28.9k	return read;
463	28.9k	}
464
465	0	int32_t mz_stream_raw_write(void stream, const void buf, int32_t size) {
466	0	mz_stream_raw raw = (mz_stream_raw )stream;
467	0	int32_t written = 0;
468
469	0	written = mz_stream_write(raw->stream.base, buf, size);
470
471	0	if (written > 0) {
472	0	raw->total_out += written;
473	0	raw->total_in += written;
474	0	}
475
476	0	return written;
477	0	}
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	23.8k	int32_t mz_stream_raw_close(void *stream) {
490	23.8k	MZ_UNUSED(stream);
491	23.8k	return MZ_OK;
492	23.8k	}
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	38.4k	int32_t mz_stream_raw_get_prop_int64(void stream, int32_t prop, int64_t value) {
500	38.4k	mz_stream_raw raw = (mz_stream_raw )stream;
501	38.4k	switch (prop) {
502	23.8k	case MZ_STREAM_PROP_TOTAL_IN:
503	23.8k	*value = raw->total_in;
504	23.8k	return MZ_OK;
505	0	case MZ_STREAM_PROP_TOTAL_OUT:
506	0	*value = raw->total_out;
507	0	return MZ_OK;
508	38.4k	}
509	14.5k	return MZ_EXIST_ERROR;
510	38.4k	}
511
512	31.1k	int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value) {
513	31.1k	mz_stream_raw raw = (mz_stream_raw )stream;
514	31.1k	switch (prop) {
515	31.1k	case MZ_STREAM_PROP_TOTAL_IN_MAX:
516	31.1k	raw->max_total_in = value;
517	31.1k	return MZ_OK;
518	31.1k	}
519	0	return MZ_EXIST_ERROR;
520	31.1k	}
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	31.1k	void *mz_stream_raw_create(void) {
532	31.1k	mz_stream_raw raw = (mz_stream_raw )calloc(1, sizeof(mz_stream_raw));
533	31.1k	if (raw)
534	31.1k	raw->stream.vtbl = &mz_stream_raw_vtbl;
535	31.1k	return raw;
536	31.1k	}
537
538	31.1k	void mz_stream_raw_delete(void **stream) {
539	31.1k	mz_stream_raw *raw = NULL;
540	31.1k	if (!stream)
541	0	return;
542	31.1k	raw = (mz_stream_raw )stream;
543	31.1k	free(raw);
544	31.1k	*stream = NULL;
545	31.1k	}