/src/libzip/lib/zip_source_file_common.c

Source
/*
  zip_source_file_common.c -- create data source from file
  Copyright (C) 1999-2025 Dieter Baron and Thomas Klausner

  This file is part of libzip, a library to manipulate ZIP archives.
  The authors can be contacted at <info@libzip.org>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:
  1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.
  3. The names of the authors may not be used to endorse or promote
     products derived from this software without specific prior
     written permission.

  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "zipint.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "zip_source_file.h"

static zip_int64_t read_file(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd);

static void zip_source_file_stat_init(zip_source_file_stat_t *st) {
    st->size = 0;
    st->mtime = time(NULL);
    st->exists = false;
    st->regular_file = false;
}

zip_source_t *zip_source_file_common_new(const char *fname, void *file, zip_uint64_t start, zip_int64_t len, const zip_stat_t *st, zip_source_file_operations_t *ops, void *ops_userdata, zip_error_t *error) {
    zip_source_file_context_t *ctx;
    zip_source_t *zs;
    zip_source_file_stat_t sb;
    zip_uint64_t length;

    if (ops == NULL) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }

    if (ops->close == NULL || ops->read == NULL || ops->seek == NULL || ops->stat == NULL) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        return NULL;
    }

    if (ops->write != NULL && (ops->commit_write == NULL || ops->create_temp_output == NULL || ops->remove == NULL || ops->rollback_write == NULL || ops->tell == NULL)) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        return NULL;
    }

    if (fname != NULL) {
        if (ops->open == NULL || ops->string_duplicate == NULL) {
            zip_error_set(error, ZIP_ER_INTERNAL, 0);
            return NULL;
        }
    }
    else if (file == NULL) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }

    if (len < 0) {
        if (len == -1) {
            len = ZIP_LENGTH_TO_END;
        }
        // TODO: return ZIP_ER_INVAL if len != ZIP_LENGTH_UNCHECKED?
        length = 0;
    }
    else {
        length = (zip_uint64_t)len;
    }

    if (start > ZIP_INT64_MAX || start + length < start) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }

    if ((ctx = zip_source_file_context_new(ops, ops_userdata)) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
    if (fname) {
        if ((ctx->fname = ops->string_duplicate(ctx, fname)) == NULL) {
            zip_error_set(error, ZIP_ER_MEMORY, 0);
            zip_source_file_context_free(ctx);
            return NULL;
        }
    }
    ctx->f = file;
    ctx->close_file = false; /* Avoid closing the file on error returns. */
    ctx->start = start;
    ctx->len = length;
    if (st) {
        (void)memcpy_s(&ctx->st, sizeof(ctx->st), st, sizeof(*st));
        ctx->st.name = NULL;
        ctx->st.valid &= ~ZIP_STAT_NAME;
    }

    if (ctx->len > 0) {
        ctx->st.size = ctx->len;
        ctx->st.valid |= ZIP_STAT_SIZE;
    }

    ctx->supports = ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_SUPPORTS_REOPEN, -1);

    zip_source_file_stat_init(&sb);
    if (!ops->stat(ctx, &sb)) {
        _zip_error_copy(error, &ctx->error);
        zip_source_file_context_free(ctx);
        return NULL;
    }

    if (!sb.exists) {
        if (ctx->fname && ctx->start == 0 && ctx->len == 0 && ops->write != NULL) {
            ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
            /* zip_open_from_source checks for this to detect non-existing files */
            zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
        }
        else {
            zip_error_set(error, ZIP_ER_READ, ENOENT);
            zip_source_file_context_free(ctx);
            return NULL;
        }
    }
    else {
        if ((ctx->st.valid & ZIP_STAT_MTIME) == 0) {
            ctx->st.mtime = sb.mtime;
            ctx->st.valid |= ZIP_STAT_MTIME;
        }
        if (sb.regular_file) {
            ctx->supports = ZIP_SOURCE_SUPPORTS_SEEKABLE;

            if (ctx->start + ctx->len > sb.size) {
                zip_error_set(error, ZIP_ER_INVAL, 0);
                zip_source_file_context_free(ctx);
                return NULL;
            }

            if (ctx->len == 0) {
                if (len != ZIP_LENGTH_UNCHECKED) {
                    ctx->len = sb.size - ctx->start;
                    ctx->st.size = ctx->len;
                    ctx->st.valid |= ZIP_STAT_SIZE;
                }

                /* when using a partial file, don't allow writing */
                if (ctx->fname && start == 0 && ops->write != NULL) {
                    ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
                }
            }
        }

        if (ctx->st.valid & ZIP_STAT_SIZE) {
            ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_AT_EOF);
        }

        ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES);
    }

    ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY);
    if (ops->create_temp_output_cloning != NULL) {
        if (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE)) {
            ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING);
        }
    }

    if ((zs = zip_source_function_create(read_file, ctx, error)) == NULL) {
        zip_source_file_context_free(ctx);
        return NULL;
    }

    ctx->close_file = true; /* On success, the file is owned by ctx. */
    return zs;
}


static zip_int64_t read_file(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd) {
    zip_source_file_context_t *ctx;
    char *buf;

    ctx = (zip_source_file_context_t *)state;
    buf = (char *)data;

    switch (cmd) {
    case ZIP_SOURCE_ACCEPT_EMPTY:
        return 0;

    case ZIP_SOURCE_AT_EOF:
        /* We only advertise support for ZIP_SOURCE_AT_EOF if ctx->len is valid. */
        return ctx->offset == ctx->len;

    case ZIP_SOURCE_BEGIN_WRITE: {
        zip_int64_t ret;
        /* write support should not be set if fname is NULL */
        if (ctx->fname == NULL) {
            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
            return -1;
        }
        ret = ctx->ops->create_temp_output(ctx);
        if (ret == 0) {
            /* Clear past error. Otherwise the error from zip_source_begin_write_cloning() will persist and be reported on zip_source_close(). */
            zip_error_set(&ctx->error, ZIP_ER_OK, 0);
        }
        return ret;
    }

    case ZIP_SOURCE_BEGIN_WRITE_CLONING:
        /* write support should not be set if fname is NULL */
        if (ctx->fname == NULL) {
            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
            return -1;
        }
        return ctx->ops->create_temp_output_cloning(ctx, len);

    case ZIP_SOURCE_CLOSE:
        if (ctx->fname) {
            ctx->ops->close(ctx);
            ctx->f = NULL;
        }
        return 0;

    case ZIP_SOURCE_COMMIT_WRITE: {
        zip_int64_t ret = ctx->ops->commit_write(ctx);
        ctx->fout = NULL;
        if (ret == 0) {
            free(ctx->tmpname);
            ctx->tmpname = NULL;
        }
        return ret;
    }

    case ZIP_SOURCE_ERROR:
        return zip_error_to_data(&ctx->error, data, len);

    case ZIP_SOURCE_FREE:
        zip_source_file_context_free(ctx);
        return 0;

    case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
        if (len < sizeof(ctx->attributes)) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
        (void)memcpy_s(data, sizeof(ctx->attributes), &ctx->attributes, sizeof(ctx->attributes));
        return sizeof(ctx->attributes);

    case ZIP_SOURCE_OPEN:
        if (ctx->fname) {
            if (ctx->ops->open(ctx) == false) {
                return -1;
            }
        }

        if (ctx->start > 0) { /* TODO: rewind on re-open */
            if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)ctx->start, SEEK_SET) == false) {
                /* TODO: skip by reading */
                return -1;
            }
        }
        ctx->offset = 0;
        return 0;

    case ZIP_SOURCE_READ: {
        zip_int64_t i;
        zip_uint64_t n;

        if (ctx->len > 0) {
            n = ZIP_MIN(ctx->len - ctx->offset, len);
        }
        else {
            n = len;
        }

        if ((i = ctx->ops->read(ctx, buf, n)) < 0) {
            zip_error_set(&ctx->error, ZIP_ER_READ, errno);
            return -1;
        }
        ctx->offset += (zip_uint64_t)i;

        return i;
    }

    case ZIP_SOURCE_REMOVE:
        return ctx->ops->remove(ctx);

    case ZIP_SOURCE_ROLLBACK_WRITE:
        ctx->ops->rollback_write(ctx);
        ctx->fout = NULL;
        free(ctx->tmpname);
        ctx->tmpname = NULL;
        return 0;

    case ZIP_SOURCE_SEEK: {
        zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset, ctx->len, data, len, &ctx->error);

        if (new_offset < 0) {
            return -1;
        }

        /* The actual offset inside the file must be representable as zip_int64_t. */
        if (new_offset > ZIP_INT64_MAX - (zip_int64_t)ctx->start) {
            zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
            return -1;
        }

        ctx->offset = (zip_uint64_t)new_offset;

        if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)(ctx->offset + ctx->start), SEEK_SET) == false) {
            return -1;
        }
        return 0;
    }

    case ZIP_SOURCE_SEEK_WRITE: {
        zip_source_args_seek_t *args;

        args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
        if (args == NULL) {
            return -1;
        }

        if (ctx->ops->seek(ctx, ctx->fout, args->offset, args->whence) == false) {
            return -1;
        }
        return 0;
    }

    case ZIP_SOURCE_STAT: {
        if (len < sizeof(ctx->st)) {
            return -1;
        }

        if (zip_error_code_zip(&ctx->stat_error) != 0) {
            zip_error_set(&ctx->error, zip_error_code_zip(&ctx->stat_error), zip_error_code_system(&ctx->stat_error));
            return -1;
        }

        (void)memcpy_s(data, sizeof(ctx->st), &ctx->st, sizeof(ctx->st));
        return sizeof(ctx->st);
    }

    case ZIP_SOURCE_SUPPORTS:
        return ctx->supports;

    case ZIP_SOURCE_TELL:
        return (zip_int64_t)ctx->offset;

    case ZIP_SOURCE_TELL_WRITE:
        return ctx->ops->tell(ctx, ctx->fout);

    case ZIP_SOURCE_WRITE:
        return ctx->ops->write(ctx, data, len);

    default:
        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
        return -1;
    }
}

zip_source_file_context_t *zip_source_file_context_new(zip_source_file_operations_t *ops, void *ops_userdata) {
    zip_source_file_context_t *ctx;

    if ((ctx = (zip_source_file_context_t *)malloc(sizeof(zip_source_file_context_t))) == NULL) {
        return NULL;
    }

    zip_error_init(&ctx->error);
    ctx->supports = 0;
    ctx->fname = NULL;
    ctx->f = NULL;
    ctx->close_file = true;
    zip_stat_init(&ctx->st);
    zip_file_attributes_init(&ctx->attributes);
    zip_error_init(&ctx->stat_error);
    ctx->start = 0;
    ctx->len = 0;
    ctx->offset = 0;
    ctx->tmpname = NULL;
    ctx->fout = NULL;
    ctx->temp_output_created = false;

    ctx->ops = ops;
    ctx->ops_userdata = ops_userdata;

    return ctx;
}
void zip_source_file_context_free(zip_source_file_context_t *ctx) {
    if (ctx == NULL) {
        return;
    }

    if (ctx->f && ctx->close_file) {
        ctx->ops->close(ctx);
    }
    free(ctx->fname);
    zip_error_fini(&ctx->error);
    zip_error_fini(&ctx->stat_error);
    free(ctx->tmpname);
    free(ctx);
}

Coverage Report

Created: 2026-10-28 07:26

Line	Count	Source
1		/*
2		zip_source_file_common.c -- create data source from file
3		Copyright (C) 1999-2025 Dieter Baron and Thomas Klausner
4
5		This file is part of libzip, a library to manipulate ZIP archives.
6		The authors can be contacted at <info@libzip.org>
7
8		Redistribution and use in source and binary forms, with or without
9		modification, are permitted provided that the following conditions
10		are met:
11		1. Redistributions of source code must retain the above copyright
12		notice, this list of conditions and the following disclaimer.
13		2. Redistributions in binary form must reproduce the above copyright
14		notice, this list of conditions and the following disclaimer in
15		the documentation and/or other materials provided with the
16		distribution.
17		3. The names of the authors may not be used to endorse or promote
18		products derived from this software without specific prior
19		written permission.
20
21		THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
22		OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23		WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24		ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25		DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
27		GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28		INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
29		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30		OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
31		IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32		*/
33
34		#include "zipint.h"
35
36		#include <stdio.h>
37		#include <stdlib.h>
38		#include <string.h>
39
40		#include "zip_source_file.h"
41
42		static zip_int64_t read_file(void state, void data, zip_uint64_t len, zip_source_cmd_t cmd);
43
44	25	static void zip_source_file_stat_init(zip_source_file_stat_t *st) {
45	25	st->size = 0;
46	25	st->mtime = time(NULL);
47	25	st->exists = false;
48	25	st->regular_file = false;
49	25	}
50
51	25	zip_source_t zip_source_file_common_new(const char fname, void file, zip_uint64_t start, zip_int64_t len, const zip_stat_t st, zip_source_file_operations_t ops, void ops_userdata, zip_error_t *error) {
52	25	zip_source_file_context_t *ctx;
53	25	zip_source_t *zs;
54	25	zip_source_file_stat_t sb;
55	25	zip_uint64_t length;
56
57	25	if (ops == NULL) {
58	0	zip_error_set(error, ZIP_ER_INVAL, 0);
59	0	return NULL;
60	0	}
61
62	25	if (ops->close == NULL \|\| ops->read == NULL \|\| ops->seek == NULL \|\| ops->stat == NULL) {
63	0	zip_error_set(error, ZIP_ER_INTERNAL, 0);
64	0	return NULL;
65	0	}
66
67	25	if (ops->write != NULL && (ops->commit_write == NULL \|\| ops->create_temp_output == NULL \|\| ops->remove == NULL \|\| ops->rollback_write == NULL \|\| ops->tell == NULL)) {
68	0	zip_error_set(error, ZIP_ER_INTERNAL, 0);
69	0	return NULL;
70	0	}
71
72	25	if (fname != NULL) {
73	25	if (ops->open == NULL \|\| ops->string_duplicate == NULL) {
74	0	zip_error_set(error, ZIP_ER_INTERNAL, 0);
75	0	return NULL;
76	0	}
77	25	}
78	0	else if (file == NULL) {
79	0	zip_error_set(error, ZIP_ER_INVAL, 0);
80	0	return NULL;
81	0	}
82
83	25	if (len < 0) {
84	25	if (len == -1) {
85	25	len = ZIP_LENGTH_TO_END;
86	25	}
87		// TODO: return ZIP_ER_INVAL if len != ZIP_LENGTH_UNCHECKED?
88	25	length = 0;
89	25	}
90	0	else {
91	0	length = (zip_uint64_t)len;
92	0	}
93
94	25	if (start > ZIP_INT64_MAX \|\| start + length < start) {
95	0	zip_error_set(error, ZIP_ER_INVAL, 0);
96	0	return NULL;
97	0	}
98
99	25	if ((ctx = zip_source_file_context_new(ops, ops_userdata)) == NULL) {
100	0	zip_error_set(error, ZIP_ER_MEMORY, 0);
101	0	return NULL;
102	0	}
103	25	if (fname) {
104	25	if ((ctx->fname = ops->string_duplicate(ctx, fname)) == NULL) {
105	0	zip_error_set(error, ZIP_ER_MEMORY, 0);
106	0	zip_source_file_context_free(ctx);
107	0	return NULL;
108	0	}
109	25	}
110	25	ctx->f = file;
111	25	ctx->close_file = false; /* Avoid closing the file on error returns. */
112	25	ctx->start = start;
113	25	ctx->len = length;
114	25	if (st) {
115	0	(void)memcpy_s(&ctx->st, sizeof(ctx->st), st, sizeof(*st));
116	0	ctx->st.name = NULL;
117	0	ctx->st.valid &= ~ZIP_STAT_NAME;
118	0	}
119
120	25	if (ctx->len > 0) {
121	0	ctx->st.size = ctx->len;
122	0	ctx->st.valid \|= ZIP_STAT_SIZE;
123	0	}
124
125	25	ctx->supports = ZIP_SOURCE_SUPPORTS_READABLE \| zip_source_make_command_bitmap(ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_SUPPORTS_REOPEN, -1);
126
127	25	zip_source_file_stat_init(&sb);
128	25	if (!ops->stat(ctx, &sb)) {
129	0	_zip_error_copy(error, &ctx->error);
130	0	zip_source_file_context_free(ctx);
131	0	return NULL;
132	0	}
133
134	25	if (!sb.exists) {
135	25	if (ctx->fname && ctx->start == 0 && ctx->len == 0 && ops->write != NULL) {
136	25	ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
137		/* zip_open_from_source checks for this to detect non-existing files */
138	25	zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
139	25	}
140	0	else {
141	0	zip_error_set(error, ZIP_ER_READ, ENOENT);
142	0	zip_source_file_context_free(ctx);
143	0	return NULL;
144	0	}
145	25	}
146	0	else {
147	0	if ((ctx->st.valid & ZIP_STAT_MTIME) == 0) {
148	0	ctx->st.mtime = sb.mtime;
149	0	ctx->st.valid \|= ZIP_STAT_MTIME;
150	0	}
151	0	if (sb.regular_file) {
152	0	ctx->supports = ZIP_SOURCE_SUPPORTS_SEEKABLE;
153
154	0	if (ctx->start + ctx->len > sb.size) {
155	0	zip_error_set(error, ZIP_ER_INVAL, 0);
156	0	zip_source_file_context_free(ctx);
157	0	return NULL;
158	0	}
159
160	0	if (ctx->len == 0) {
161	0	if (len != ZIP_LENGTH_UNCHECKED) {
162	0	ctx->len = sb.size - ctx->start;
163	0	ctx->st.size = ctx->len;
164	0	ctx->st.valid \|= ZIP_STAT_SIZE;
165	0	}
166
167		/* when using a partial file, don't allow writing */
168	0	if (ctx->fname && start == 0 && ops->write != NULL) {
169	0	ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
170	0	}
171	0	}
172	0	}
173
174	0	if (ctx->st.valid & ZIP_STAT_SIZE) {
175	0	ctx->supports \|= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_AT_EOF);
176	0	}
177
178	0	ctx->supports \|= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES);
179	0	}
180
181	25	ctx->supports \|= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY);
182	25	if (ops->create_temp_output_cloning != NULL) {
183	25	if (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE)) {
184	25	ctx->supports \|= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING);
185	25	}
186	25	}
187
188	25	if ((zs = zip_source_function_create(read_file, ctx, error)) == NULL) {
189	0	zip_source_file_context_free(ctx);
190	0	return NULL;
191	0	}
192
193	25	ctx->close_file = true; /* On success, the file is owned by ctx. */
194	25	return zs;
195	25	}
196
197
198	100	static zip_int64_t read_file(void state, void data, zip_uint64_t len, zip_source_cmd_t cmd) {
199	100	zip_source_file_context_t *ctx;
200	100	char *buf;
201
202	100	ctx = (zip_source_file_context_t *)state;
203	100	buf = (char *)data;
204
205	100	switch (cmd) {
206	0	case ZIP_SOURCE_ACCEPT_EMPTY:
207	0	return 0;
208
209	0	case ZIP_SOURCE_AT_EOF:
210		/* We only advertise support for ZIP_SOURCE_AT_EOF if ctx->len is valid. */
211	0	return ctx->offset == ctx->len;
212
213	0	case ZIP_SOURCE_BEGIN_WRITE: {
214	0	zip_int64_t ret;
215		/* write support should not be set if fname is NULL */
216	0	if (ctx->fname == NULL) {
217	0	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
218	0	return -1;
219	0	}
220	0	ret = ctx->ops->create_temp_output(ctx);
221	0	if (ret == 0) {
222		/* Clear past error. Otherwise the error from zip_source_begin_write_cloning() will persist and be reported on zip_source_close(). */
223	0	zip_error_set(&ctx->error, ZIP_ER_OK, 0);
224	0	}
225	0	return ret;
226	0	}
227
228	0	case ZIP_SOURCE_BEGIN_WRITE_CLONING:
229		/* write support should not be set if fname is NULL */
230	0	if (ctx->fname == NULL) {
231	0	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
232	0	return -1;
233	0	}
234	0	return ctx->ops->create_temp_output_cloning(ctx, len);
235
236	0	case ZIP_SOURCE_CLOSE:
237	0	if (ctx->fname) {
238	0	ctx->ops->close(ctx);
239	0	ctx->f = NULL;
240	0	}
241	0	return 0;
242
243	0	case ZIP_SOURCE_COMMIT_WRITE: {
244	0	zip_int64_t ret = ctx->ops->commit_write(ctx);
245	0	ctx->fout = NULL;
246	0	if (ret == 0) {
247	0	free(ctx->tmpname);
248	0	ctx->tmpname = NULL;
249	0	}
250	0	return ret;
251	0	}
252
253	25	case ZIP_SOURCE_ERROR:
254	25	return zip_error_to_data(&ctx->error, data, len);
255
256	25	case ZIP_SOURCE_FREE:
257	25	zip_source_file_context_free(ctx);
258	25	return 0;
259
260	0	case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
261	0	if (len < sizeof(ctx->attributes)) {
262	0	zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
263	0	return -1;
264	0	}
265	0	(void)memcpy_s(data, sizeof(ctx->attributes), &ctx->attributes, sizeof(ctx->attributes));
266	0	return sizeof(ctx->attributes);
267
268	0	case ZIP_SOURCE_OPEN:
269	0	if (ctx->fname) {
270	0	if (ctx->ops->open(ctx) == false) {
271	0	return -1;
272	0	}
273	0	}
274
275	0	if (ctx->start > 0) { /* TODO: rewind on re-open */
276	0	if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)ctx->start, SEEK_SET) == false) {
277		/* TODO: skip by reading */
278	0	return -1;
279	0	}
280	0	}
281	0	ctx->offset = 0;
282	0	return 0;
283
284	0	case ZIP_SOURCE_READ: {
285	0	zip_int64_t i;
286	0	zip_uint64_t n;
287
288	0	if (ctx->len > 0) {
289	0	n = ZIP_MIN(ctx->len - ctx->offset, len);
290	0	}
291	0	else {
292	0	n = len;
293	0	}
294
295	0	if ((i = ctx->ops->read(ctx, buf, n)) < 0) {
296	0	zip_error_set(&ctx->error, ZIP_ER_READ, errno);
297	0	return -1;
298	0	}
299	0	ctx->offset += (zip_uint64_t)i;
300
301	0	return i;
302	0	}
303
304	0	case ZIP_SOURCE_REMOVE:
305	0	return ctx->ops->remove(ctx);
306
307	0	case ZIP_SOURCE_ROLLBACK_WRITE:
308	0	ctx->ops->rollback_write(ctx);
309	0	ctx->fout = NULL;
310	0	free(ctx->tmpname);
311	0	ctx->tmpname = NULL;
312	0	return 0;
313
314	0	case ZIP_SOURCE_SEEK: {
315	0	zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset, ctx->len, data, len, &ctx->error);
316
317	0	if (new_offset < 0) {
318	0	return -1;
319	0	}
320
321		/* The actual offset inside the file must be representable as zip_int64_t. */
322	0	if (new_offset > ZIP_INT64_MAX - (zip_int64_t)ctx->start) {
323	0	zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
324	0	return -1;
325	0	}
326
327	0	ctx->offset = (zip_uint64_t)new_offset;
328
329	0	if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)(ctx->offset + ctx->start), SEEK_SET) == false) {
330	0	return -1;
331	0	}
332	0	return 0;
333	0	}
334
335	0	case ZIP_SOURCE_SEEK_WRITE: {
336	0	zip_source_args_seek_t *args;
337
338	0	args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
339	0	if (args == NULL) {
340	0	return -1;
341	0	}
342
343	0	if (ctx->ops->seek(ctx, ctx->fout, args->offset, args->whence) == false) {
344	0	return -1;
345	0	}
346	0	return 0;
347	0	}
348
349	25	case ZIP_SOURCE_STAT: {
350	25	if (len < sizeof(ctx->st)) {
351	0	return -1;
352	0	}
353
354	25	if (zip_error_code_zip(&ctx->stat_error) != 0) {
355	25	zip_error_set(&ctx->error, zip_error_code_zip(&ctx->stat_error), zip_error_code_system(&ctx->stat_error));
356	25	return -1;
357	25	}
358
359	0	(void)memcpy_s(data, sizeof(ctx->st), &ctx->st, sizeof(ctx->st));
360	0	return sizeof(ctx->st);
361	25	}
362
363	25	case ZIP_SOURCE_SUPPORTS:
364	25	return ctx->supports;
365
366	0	case ZIP_SOURCE_TELL:
367	0	return (zip_int64_t)ctx->offset;
368
369	0	case ZIP_SOURCE_TELL_WRITE:
370	0	return ctx->ops->tell(ctx, ctx->fout);
371
372	0	case ZIP_SOURCE_WRITE:
373	0	return ctx->ops->write(ctx, data, len);
374
375	0	default:
376	0	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
377	0	return -1;
378	100	}
379	100	}
380
381	25	zip_source_file_context_t zip_source_file_context_new(zip_source_file_operations_t ops, void *ops_userdata) {
382	25	zip_source_file_context_t *ctx;
383
384	25	if ((ctx = (zip_source_file_context_t *)malloc(sizeof(zip_source_file_context_t))) == NULL) {
385	0	return NULL;
386	0	}
387
388	25	zip_error_init(&ctx->error);
389	25	ctx->supports = 0;
390	25	ctx->fname = NULL;
391	25	ctx->f = NULL;
392	25	ctx->close_file = true;
393	25	zip_stat_init(&ctx->st);
394	25	zip_file_attributes_init(&ctx->attributes);
395	25	zip_error_init(&ctx->stat_error);
396	25	ctx->start = 0;
397	25	ctx->len = 0;
398	25	ctx->offset = 0;
399	25	ctx->tmpname = NULL;
400	25	ctx->fout = NULL;
401	25	ctx->temp_output_created = false;
402
403	25	ctx->ops = ops;
404	25	ctx->ops_userdata = ops_userdata;
405
406	25	return ctx;
407	25	}
408	25	void zip_source_file_context_free(zip_source_file_context_t *ctx) {
409	25	if (ctx == NULL) {
410	0	return;
411	0	}
412
413	25	if (ctx->f && ctx->close_file) {
414	0	ctx->ops->close(ctx);
415	0	}
416	25	free(ctx->fname);
417	25	zip_error_fini(&ctx->error);
418	25	zip_error_fini(&ctx->stat_error);
419	25	free(ctx->tmpname);
420	25	free(ctx);
421	25	}