/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(stream) != 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(stream) != 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) {
    uint8_t buf[8];
    int32_t n = 0;

    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(stream, 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(stream) != 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(stream) != 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(stream, 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(stream, prop, value);
}

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

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 **stream) {
    mz_stream_raw *raw = NULL;

    raw = (mz_stream_raw *)calloc(1, sizeof(mz_stream_raw));
    if (raw)
        raw->stream.vtbl = &mz_stream_raw_vtbl;
    if (stream)
        *stream = raw;

    return raw;
}

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

Coverage Report

Created: 2023-03-26 06:14

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