/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	0	#define MZ_STREAM_FIND_SIZE (1024)
17
18		/***************************************************************************/
19
20	0	int32_t mz_stream_open(void stream, const char path, int32_t mode) {
21	0	mz_stream strm = (mz_stream )stream;
22	0	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->open)
23	0	return MZ_STREAM_ERROR;
24	0	return strm->vtbl->open(strm, path, mode);
25	0	}
26
27	5.10k	int32_t mz_stream_is_open(void *stream) {
28	5.10k	mz_stream strm = (mz_stream )stream;
29	5.10k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->is_open)
30	0	return MZ_STREAM_ERROR;
31	5.10k	return strm->vtbl->is_open(strm);
32	5.10k	}
33
34	1.23k	int32_t mz_stream_read(void stream, void buf, int32_t size) {
35	1.23k	mz_stream strm = (mz_stream )stream;
36	1.23k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->read)
37	0	return MZ_PARAM_ERROR;
38	1.23k	if (mz_stream_is_open(stream) != MZ_OK)
39	0	return MZ_STREAM_ERROR;
40	1.23k	return strm->vtbl->read(strm, buf, size);
41	1.23k	}
42
43	1.23k	static int32_t mz_stream_read_value(void stream, uint64_t value, int32_t len) {
44	1.23k	uint8_t buf[8];
45	1.23k	int32_t n = 0;
46	1.23k	int32_t i = 0;
47
48	1.23k	*value = 0;
49	1.23k	if (mz_stream_read(stream, buf, len) == len) {
50	2.29k	for (n = 0; n < len; n += 1, i += 8)
51	1.26k	*value += ((uint64_t)buf[n]) << i;
52	1.02k	} else if (mz_stream_error(stream))
53	0	return MZ_STREAM_ERROR;
54	210	else
55	210	return MZ_END_OF_STREAM;
56
57	1.02k	return MZ_OK;
58	1.23k	}
59
60	972	int32_t mz_stream_read_uint8(void stream, uint8_t value) {
61	972	int32_t err = MZ_OK;
62	972	uint64_t value64 = 0;
63
64	972	*value = 0;
65	972	err = mz_stream_read_value(stream, &value64, sizeof(uint8_t));
66	972	if (err == MZ_OK)
67	784	*value = (uint8_t)value64;
68	972	return err;
69	972	}
70
71	264	int32_t mz_stream_read_uint16(void stream, uint16_t value) {
72	264	int32_t err = MZ_OK;
73	264	uint64_t value64 = 0;
74
75	264	*value = 0;
76	264	err = mz_stream_read_value(stream, &value64, sizeof(uint16_t));
77	264	if (err == MZ_OK)
78	242	*value = (uint16_t)value64;
79	264	return err;
80	264	}
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	1.55k	int32_t mz_stream_write(void stream, const void buf, int32_t size) {
102	1.55k	mz_stream strm = (mz_stream )stream;
103	1.55k	if (size == 0)
104	0	return size;
105	1.55k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->write)
106	0	return MZ_PARAM_ERROR;
107	1.55k	if (mz_stream_is_open(stream) != MZ_OK)
108	295	return MZ_STREAM_ERROR;
109	1.26k	return strm->vtbl->write(strm, buf, size);
110	1.55k	}
111
112	1.13k	static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
113	1.13k	uint8_t buf[8];
114	1.13k	int32_t n = 0;
115
116	3.15k	for (n = 0; n < len; n += 1) {
117	2.02k	buf[n] = (uint8_t)(value & 0xff);
118	2.02k	value >>= 8;
119	2.02k	}
120
121	1.13k	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	1.13k	if (mz_stream_write(stream, buf, len) != len)
128	295	return MZ_STREAM_ERROR;
129
130	840	return MZ_OK;
131	1.13k	}
132
133	840	int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
134	840	return mz_stream_write_value(stream, value, sizeof(uint8_t));
135	840	}
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	295	int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
142	295	return mz_stream_write_value(stream, value, sizeof(uint32_t));
143	295	}
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	210	int32_t mz_stream_copy(void target, void source, int32_t len) {
154	210	return mz_stream_copy_stream(target, NULL, source, NULL, len);
155	210	}
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	210	mz_stream_read_cb read_cb, int32_t len) {
163	210	uint8_t buf[16384];
164	210	int32_t bytes_to_copy = 0;
165	210	int32_t read = 0;
166	210	int32_t written = 0;
167
168	210	if (!write_cb)
169	210	write_cb = mz_stream_write;
170	210	if (!read_cb)
171	210	read_cb = mz_stream_read;
172
173	210	while (len > 0) {
174	0	bytes_to_copy = len;
175	0	if (bytes_to_copy > (int32_t)sizeof(buf))
176	0	bytes_to_copy = sizeof(buf);
177	0	read = read_cb(source, buf, bytes_to_copy);
178	0	if (read <= 0)
179	0	return MZ_STREAM_ERROR;
180	0	written = write_cb(target, buf, read);
181	0	if (written != read)
182	0	return MZ_STREAM_ERROR;
183	0	len -= read;
184	0	}
185
186	210	return MZ_OK;
187	210	}
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	1.47k	int64_t mz_stream_tell(void *stream) {
215	1.47k	mz_stream strm = (mz_stream )stream;
216	1.47k	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->tell)
217	0	return MZ_PARAM_ERROR;
218	1.47k	if (mz_stream_is_open(stream) != MZ_OK)
219	420	return MZ_STREAM_ERROR;
220	1.05k	return strm->vtbl->tell(strm);
221	1.47k	}
222
223	630	int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
224	630	mz_stream strm = (mz_stream )stream;
225	630	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->seek)
226	0	return MZ_PARAM_ERROR;
227	630	if (mz_stream_is_open(stream) != MZ_OK)
228	0	return MZ_STREAM_ERROR;
229	630	if (origin == MZ_SEEK_SET && offset < 0)
230	0	return MZ_SEEK_ERROR;
231	630	return strm->vtbl->seek(strm, offset, origin);
232	630	}
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	0	int32_t mz_stream_find_reverse(void stream, const void find, int32_t find_size, int64_t max_seek, int64_t *position) {
293	0	uint8_t buf[MZ_STREAM_FIND_SIZE];
294	0	int32_t buf_pos = 0;
295	0	int32_t read_size = MZ_STREAM_FIND_SIZE;
296	0	int64_t read_pos = 0;
297	0	int32_t read = 0;
298	0	int64_t start_pos = 0;
299	0	int64_t disk_pos = 0;
300	0	uint8_t first = 1;
301	0	int32_t i = 0;
302	0	int32_t err = MZ_OK;
303
304	0	if (!stream \|\| !find \|\| !position)
305	0	return MZ_PARAM_ERROR;
306	0	if (find_size < 0 \|\| find_size >= (int32_t)sizeof(buf))
307	0	return MZ_PARAM_ERROR;
308
309	0	*position = -1;
310
311	0	start_pos = mz_stream_tell(stream);
312
313	0	while (read_pos < max_seek) {
314	0	if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
315	0	read_size = (int32_t)(max_seek - read_pos);
316
317	0	if (mz_stream_seek(stream, start_pos - (read_pos + read_size), MZ_SEEK_SET) != MZ_OK)
318	0	break;
319	0	read = mz_stream_read(stream, buf, read_size);
320	0	if ((read <= 0) \|\| (read + buf_pos < find_size))
321	0	break;
322	0	if (read + buf_pos < MZ_STREAM_FIND_SIZE)
323	0	memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);
324
325	0	for (i = find_size; i <= (read + buf_pos); i += 1) {
326	0	if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
327	0	continue;
328
329	0	disk_pos = mz_stream_tell(stream);
330
331		/* Seek to position on disk where the data was found */
332	0	err = mz_stream_seek(stream, disk_pos + buf_pos - i, MZ_SEEK_SET);
333	0	if (err != MZ_OK)
334	0	return MZ_EXIST_ERROR;
335
336	0	*position = start_pos - (read_pos - buf_pos + i);
337	0	return MZ_OK;
338	0	}
339
340	0	if (first) {
341	0	read -= find_size;
342	0	read_size -= find_size;
343	0	buf_pos = find_size;
344	0	first = 0;
345	0	}
346
347	0	if (read == 0)
348	0	break;
349
350	0	memmove(buf + read_size, buf, find_size);
351	0	read_pos += read;
352	0	}
353
354	0	return MZ_EXIST_ERROR;
355	0	}
356
357	210	int32_t mz_stream_close(void *stream) {
358	210	mz_stream strm = (mz_stream )stream;
359	210	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->close)
360	0	return MZ_PARAM_ERROR;
361	210	if (mz_stream_is_open(stream) != MZ_OK)
362	0	return MZ_STREAM_ERROR;
363	210	return strm->vtbl->close(strm);
364	210	}
365
366	210	int32_t mz_stream_error(void *stream) {
367	210	mz_stream strm = (mz_stream )stream;
368	210	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->error)
369	0	return MZ_PARAM_ERROR;
370	210	return strm->vtbl->error(strm);
371	210	}
372
373	0	int32_t mz_stream_set_base(void stream, void base) {
374	0	mz_stream strm = (mz_stream )stream;
375	0	strm->base = (mz_stream *)base;
376	0	return MZ_OK;
377	0	}
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	630	int32_t mz_stream_get_prop_int64(void stream, int32_t prop, int64_t value) {
387	630	mz_stream strm = (mz_stream )stream;
388	630	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->get_prop_int64)
389	630	return MZ_PARAM_ERROR;
390	0	return strm->vtbl->get_prop_int64(stream, prop, value);
391	630	}
392
393	210	int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value) {
394	210	mz_stream strm = (mz_stream )stream;
395	210	if (!strm \|\| !strm->vtbl \|\| !strm->vtbl->set_prop_int64)
396	210	return MZ_PARAM_ERROR;
397	0	return strm->vtbl->set_prop_int64(stream, prop, value);
398	210	}
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	210	void mz_stream_delete(void **stream) {
407	210	mz_stream *strm = NULL;
408	210	if (!stream)
409	0	return;
410	210	strm = (mz_stream )stream;
411	210	if (strm && strm->vtbl && strm->vtbl->destroy)
412	210	strm->vtbl->destroy(stream);
413	210	*stream = NULL;
414	210	}
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	0	int32_t mz_stream_raw_open(void stream, const char path, int32_t mode) {
428	0	MZ_UNUSED(stream);
429	0	MZ_UNUSED(path);
430	0	MZ_UNUSED(mode);
431
432	0	return MZ_OK;
433	0	}
434
435	0	int32_t mz_stream_raw_is_open(void *stream) {
436	0	mz_stream_raw raw = (mz_stream_raw )stream;
437	0	return mz_stream_is_open(raw->stream.base);
438	0	}
439
440	0	int32_t mz_stream_raw_read(void stream, void buf, int32_t size) {
441	0	mz_stream_raw raw = (mz_stream_raw )stream;
442	0	int32_t bytes_to_read = size;
443	0	int32_t read = 0;
444
445	0	if (raw->max_total_in > 0) {
446	0	if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
447	0	bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
448	0	}
449
450	0	read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
451
452	0	if (read > 0) {
453	0	raw->total_in += read;
454	0	raw->total_out += read;
455	0	}
456
457	0	return read;
458	0	}
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	0	int32_t mz_stream_raw_close(void *stream) {
485	0	MZ_UNUSED(stream);
486	0	return MZ_OK;
487	0	}
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	0	int32_t mz_stream_raw_get_prop_int64(void stream, int32_t prop, int64_t value) {
495	0	mz_stream_raw raw = (mz_stream_raw )stream;
496	0	switch (prop) {
497	0	case MZ_STREAM_PROP_TOTAL_IN:
498	0	*value = raw->total_in;
499	0	return MZ_OK;
500	0	case MZ_STREAM_PROP_TOTAL_OUT:
501	0	*value = raw->total_out;
502	0	return MZ_OK;
503	0	}
504	0	return MZ_EXIST_ERROR;
505	0	}
506
507	0	int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value) {
508	0	mz_stream_raw raw = (mz_stream_raw )stream;
509	0	switch (prop) {
510	0	case MZ_STREAM_PROP_TOTAL_IN_MAX:
511	0	raw->max_total_in = value;
512	0	return MZ_OK;
513	0	}
514	0	return MZ_EXIST_ERROR;
515	0	}
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	0	void mz_stream_raw_create(void *stream) {
537	0	mz_stream_raw *raw = NULL;
538
539	0	raw = (mz_stream_raw *)calloc(1, sizeof(mz_stream_raw));
540	0	if (raw)
541	0	raw->stream.vtbl = &mz_stream_raw_vtbl;
542	0	if (stream)
543	0	*stream = raw;
544
545	0	return raw;
546	0	}
547
548	0	void mz_stream_raw_delete(void **stream) {
549	0	mz_stream_raw *raw = NULL;
550	0	if (!stream)
551	0	return;
552	0	raw = (mz_stream_raw )stream;
553	0	if (raw)
554	0	free(raw);
555	0	*stream = NULL;
556	0	}