zip_close.c File Reference

#include "zipint.h"
#include <stdio.h>
#include <stdlib.h>

Go to the source code of this file.

Functions
static int	add_data (zip_t *, zip_source_t *, zip_dirent_t *, zip_uint32_t)
static int	copy_data (zip_t *, zip_uint64_t)
static int	copy_source (zip_t *, zip_source_t *, zip_int64_t)
static int	write_cdir (zip_t *, const zip_filelist_t *, zip_uint64_t)
static int	write_data_descriptor (zip_t *za, const zip_dirent_t *dirent, int is_zip64)
ZIP_EXTERN int	zip_close (zip_t *za)
int	_zip_changed (const zip_t *za, zip_uint64_t *survivorsp)

Function Documentation

_zip_changed()

int _zip_changed	(	const zip_t *	za,
		zip_uint64_t *	survivorsp
	)

Definition at line 655 of file zip_close.c.

                                                        {
    int changed;
    zip_uint64_t i, survivors;
 
    changed = 0;
    survivors = 0;
 
    if (za->comment_changed || za->ch_flags != za->flags) {
        changed = 1;
    }
 
    for (i = 0; i < za->nentry; i++) {
        if (ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
            changed = 1;
        }
        if (!za->entry[i].deleted) {
            survivors++;
        }
    }
 
    if (survivorsp) {
        *survivorsp = survivors;
    }
 
    return changed;
}

References zip::ch_flags, zip::comment_changed, zip_entry::deleted, zip::entry, zip::flags, i, zip::nentry, za, and ZIP_ENTRY_HAS_CHANGES.

Referenced by zip_close(), and zip_set_archive_flag().

add_data()

static int add_data ( zip_t *  za, zip_source_t *  src, zip_dirent_t *  de, zip_uint32_t  changed  )

static

Definition at line 288 of file zip_close.c.

                                                                               {
    zip_int64_t offstart, offdata, offend, data_length;
    zip_stat_t st;
    zip_file_attributes_t attributes;
    zip_source_t *src_final, *src_tmp;
    int ret;
    int is_zip64;
    zip_flags_t flags;
    bool needs_recompress, needs_decompress, needs_crc, needs_compress, needs_reencrypt, needs_decrypt, needs_encrypt;
 
    if (zip_source_stat(src, &st) < 0) {
        _zip_error_set_from_source(&za->error, src);
        return -1;
    }
 
    if ((st.valid & ZIP_STAT_COMP_METHOD) == 0) {
        st.valid |= ZIP_STAT_COMP_METHOD;
        st.comp_method = ZIP_CM_STORE;
    }
 
    if (ZIP_CM_IS_DEFAULT(de->comp_method) && st.comp_method != ZIP_CM_STORE)
        de->comp_method = st.comp_method;
    else if (de->comp_method == ZIP_CM_STORE && (st.valid & ZIP_STAT_SIZE)) {
        st.valid |= ZIP_STAT_COMP_SIZE;
        st.comp_size = st.size;
    }
    else {
        /* we'll recompress */
        st.valid &= ~ZIP_STAT_COMP_SIZE;
    }
 
    if ((st.valid & ZIP_STAT_ENCRYPTION_METHOD) == 0) {
        st.valid |= ZIP_STAT_ENCRYPTION_METHOD;
        st.encryption_method = ZIP_EM_NONE;
    }
 
    flags = ZIP_EF_LOCAL;
 
    if ((st.valid & ZIP_STAT_SIZE) == 0) {
        flags |= ZIP_FL_FORCE_ZIP64;
        data_length = -1;
    }
    else {
        de->uncomp_size = st.size;
        /* this is technically incorrect (copy_source counts compressed data), but it's the best we have */
        data_length = (zip_int64_t)st.size;
 
        if ((st.valid & ZIP_STAT_COMP_SIZE) == 0) {
            zip_uint64_t max_compressed_size;
            zip_uint16_t compression_method = ZIP_CM_ACTUAL(de->comp_method);
 
            if (compression_method == ZIP_CM_STORE) {
                max_compressed_size = st.size;
            }
            else {
                zip_compression_algorithm_t *algorithm = _zip_get_compression_algorithm(compression_method, true);
                if (algorithm == NULL) {
                    max_compressed_size = ZIP_UINT64_MAX;
                }
                else {
                    max_compressed_size = algorithm->maximum_compressed_size(st.size);
                }
            }
 
            if (max_compressed_size > 0xffffffffu) {
                flags |= ZIP_FL_FORCE_ZIP64;
            }
        }
        else {
            de->comp_size = st.comp_size;
            data_length = (zip_int64_t)st.comp_size;
        }
    }
 
    if ((offstart = zip_source_tell_write(za->src)) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    /* as long as we don't support non-seekable output, clear data descriptor bit */
    de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
    if ((is_zip64 = _zip_dirent_write(za, de, flags)) < 0) {
        return -1;
    }
 
    needs_recompress = st.comp_method != ZIP_CM_ACTUAL(de->comp_method);
    needs_decompress = needs_recompress && (st.comp_method != ZIP_CM_STORE);
    /* in these cases we can compute the CRC ourselves, so we do */
    needs_crc = (st.comp_method == ZIP_CM_STORE) || needs_decompress;
    needs_compress = needs_recompress && (de->comp_method != ZIP_CM_STORE);
 
    needs_reencrypt = needs_recompress || (de->changed & ZIP_DIRENT_PASSWORD) || (de->encryption_method != st.encryption_method);
    needs_decrypt = needs_reencrypt && (st.encryption_method != ZIP_EM_NONE);
    needs_encrypt = needs_reencrypt && (de->encryption_method != ZIP_EM_NONE);
 
    src_final = src;
    zip_source_keep(src_final);
 
    if (needs_decrypt) {
        zip_encryption_implementation impl;
 
        if ((impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
            zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
            zip_source_free(src_final);
            return -1;
        }
        if ((src_tmp = impl(za, src_final, st.encryption_method, ZIP_CODEC_DECODE, za->default_password)) == NULL) {
            /* error set by impl */
            zip_source_free(src_final);
            return -1;
        }
 
        zip_source_free(src_final);
        src_final = src_tmp;
    }
 
    if (needs_decompress) {
        if ((src_tmp = zip_source_decompress(za, src_final, st.comp_method)) == NULL) {
            zip_source_free(src_final);
            return -1;
        }
 
        zip_source_free(src_final);
        src_final = src_tmp;
    }
 
    if (needs_crc) {
        if ((src_tmp = zip_source_crc_create(src_final, 0, &za->error)) == NULL) {
            zip_source_free(src_final);
            return -1;
        }
 
        zip_source_free(src_final);
        src_final = src_tmp;
    }
 
    if (needs_compress) {
        if ((src_tmp = zip_source_compress(za, src_final, de->comp_method, de->compression_level)) == NULL) {
            zip_source_free(src_final);
            return -1;
        }
 
        zip_source_free(src_final);
        src_final = src_tmp;
    }
 
 
    if (needs_encrypt) {
        zip_encryption_implementation impl;
        const char *password = NULL;
 
        if (de->password) {
            password = de->password;
        }
        else if (za->default_password) {
            password = za->default_password;
        }
 
        if ((impl = _zip_get_encryption_implementation(de->encryption_method, ZIP_CODEC_ENCODE)) == NULL) {
            zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
            zip_source_free(src_final);
            return -1;
        }
 
        if (de->encryption_method == ZIP_EM_TRAD_PKWARE) {
            de->bitflags |= ZIP_GPBF_DATA_DESCRIPTOR;
 
            /* PKWare encryption uses last_mod, make sure it gets the right value. */
            if (de->changed & ZIP_DIRENT_LAST_MOD) {
                zip_stat_t st_mtime;
                zip_stat_init(&st_mtime);
                st_mtime.valid = ZIP_STAT_MTIME;
                st_mtime.mtime = de->last_mod;
                if ((src_tmp = _zip_source_window_new(src_final, 0, -1, &st_mtime, NULL, NULL, 0, &za->error)) == NULL) {
                    zip_source_free(src_final);
                    return -1;
                }
                zip_source_free(src_final);
                src_final = src_tmp;
            }
        }
 
        if ((src_tmp = impl(za, src_final, de->encryption_method, ZIP_CODEC_ENCODE, password)) == NULL) {
            /* error set by impl */
            zip_source_free(src_final);
            return -1;
        }
 
        zip_source_free(src_final);
        src_final = src_tmp;
    }
 
 
    if ((offdata = zip_source_tell_write(za->src)) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    ret = copy_source(za, src_final, data_length);
 
    if (zip_source_stat(src_final, &st) < 0) {
        _zip_error_set_from_source(&za->error, src_final);
        ret = -1;
    }
 
    if (zip_source_get_file_attributes(src_final, &attributes) != 0) {
        _zip_error_set_from_source(&za->error, src_final);
        ret = -1;
    }
 
    zip_source_free(src_final);
 
    if (ret < 0) {
        return -1;
    }
 
    if ((offend = zip_source_tell_write(za->src)) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    if (zip_source_seek_write(za->src, offstart, SEEK_SET) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    if ((st.valid & (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) != (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) {
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
 
    if ((de->changed & ZIP_DIRENT_LAST_MOD) == 0) {
        if (st.valid & ZIP_STAT_MTIME)
            de->last_mod = st.mtime;
        else
            time(&de->last_mod);
    }
    de->comp_method = st.comp_method;
    de->crc = st.crc;
    de->uncomp_size = st.size;
    de->comp_size = (zip_uint64_t)(offend - offdata);
    _zip_dirent_apply_attributes(de, &attributes, (flags & ZIP_FL_FORCE_ZIP64) != 0, changed);
 
    if ((ret = _zip_dirent_write(za, de, flags)) < 0)
        return -1;
 
    if (is_zip64 != ret) {
        /* Zip64 mismatch between preliminary file header written before data and final file header written afterwards */
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
 
    if (zip_source_seek_write(za->src, offend, SEEK_SET) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
        if (write_data_descriptor(za, de, is_zip64) < 0) {
            return -1;
        }
    }
 
    return 0;
}

References _zip_dirent_apply_attributes(), _zip_dirent_write(), _zip_error_set_from_source(), _zip_get_compression_algorithm(), _zip_get_encryption_implementation(), _zip_source_window_new(), zip_dirent::bitflags, zip_dirent::changed, zip_stat::comp_method, zip_dirent::comp_method, zip_stat::comp_size, zip_dirent::comp_size, zip_dirent::compression_level, copy_source(), zip_stat::crc, zip_dirent::crc, zip::default_password, zip_stat::encryption_method, zip_dirent::encryption_method, zip::error, flags, if(), zip_dirent::last_mod, zip_compression_algorithm::maximum_compressed_size, zip_stat::mtime, NULL, zip_dirent::password, SEEK_SET, zip_stat::size, zip::src, src, time, zip_dirent::uncomp_size, zip_stat::valid, write_data_descriptor(), za, ZIP_CM_ACTUAL, ZIP_CM_IS_DEFAULT, ZIP_CM_STORE, ZIP_CODEC_DECODE, ZIP_CODEC_ENCODE, ZIP_DIRENT_LAST_MOD, ZIP_DIRENT_PASSWORD, ZIP_EF_LOCAL, ZIP_EM_NONE, ZIP_EM_TRAD_PKWARE, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INTERNAL, zip_error_set(), ZIP_FL_FORCE_ZIP64, ZIP_GPBF_DATA_DESCRIPTOR, zip_source_compress(), zip_source_crc_create(), zip_source_decompress(), zip_source_free(), zip_source_get_file_attributes(), zip_source_keep(), zip_source_seek_write(), zip_source_stat(), zip_source_tell_write(), ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, ZIP_STAT_CRC, ZIP_STAT_ENCRYPTION_METHOD, zip_stat_init(), ZIP_STAT_MTIME, ZIP_STAT_SIZE, and ZIP_UINT64_MAX.

Referenced by zip_close().

copy_data()

static int copy_data ( zip_t *  za, zip_uint64_t  len  )

static

Definition at line 556 of file zip_close.c.

                                       {
    DEFINE_BYTE_ARRAY(buf, BUFSIZE);
    size_t n;
    double total = (double)len;
 
    if (!byte_array_init(buf, BUFSIZE)) {
        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
        return -1;
    }
 
    while (len > 0) {
        n = len > BUFSIZE ? BUFSIZE : len;
        if (_zip_read(za->src, buf, n, &za->error) < 0) {
            byte_array_fini(buf);
            return -1;
        }
 
        if (_zip_write(za, buf, n) < 0) {
            byte_array_fini(buf);
            return -1;
        }
 
        len -= n;
 
        if (_zip_progress_update(za->progress, (total - (double)len) / total) != 0) {
            zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
            return -1;
        }
    }
 
    byte_array_fini(buf);
    return 0;
}

References _zip_progress_update(), _zip_read(), _zip_write(), BUFSIZE, byte_array_fini, byte_array_init, DEFINE_BYTE_ARRAY, zip::error, len, n, zip::progress, zip::src, za, ZIP_ER_CANCELLED, ZIP_ER_MEMORY, and zip_error_set().

Referenced by zip_close().

copy_source()

static int copy_source ( zip_t *  za, zip_source_t *  src, zip_int64_t  data_length  )

static

Definition at line 592 of file zip_close.c.

                                                                   {
    DEFINE_BYTE_ARRAY(buf, BUFSIZE);
    zip_int64_t n, current;
    int ret;
 
    if (zip_source_open(src) < 0) {
        _zip_error_set_from_source(&za->error, src);
        return -1;
    }
 
    if (!byte_array_init(buf, BUFSIZE)) {
        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
        return -1;
    }
 
    ret = 0;
    current = 0;
    while ((n = zip_source_read(src, buf, BUFSIZE)) > 0) {
        if (_zip_write(za, buf, (zip_uint64_t)n) < 0) {
            ret = -1;
            break;
        }
        if (n == BUFSIZE && za->progress && data_length > 0) {
            current += n;
            if (_zip_progress_update(za->progress, (double)current / (double)data_length) != 0) {
                zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
                ret = -1;
                break;
            }
        }
    }
 
    if (n < 0) {
        _zip_error_set_from_source(&za->error, src);
        ret = -1;
    }
 
    byte_array_fini(buf);
 
    zip_source_close(src);
 
    return ret;
}

References _zip_error_set_from_source(), _zip_progress_update(), _zip_write(), BUFSIZE, byte_array_fini, byte_array_init, DEFINE_BYTE_ARRAY, zip::error, n, zip::progress, src, za, ZIP_ER_CANCELLED, ZIP_ER_MEMORY, zip_error_set(), zip_source_close(), zip_source_open(), and zip_source_read().

Referenced by add_data().

write_cdir()

static int write_cdir ( zip_t *  za, const zip_filelist_t *  filelist, zip_uint64_t  survivors  )

static

Definition at line 637 of file zip_close.c.

                                                                              {
    if (zip_source_tell_write(za->src) < 0) {
        return -1;
    }
 
    if (_zip_cdir_write(za, filelist, survivors) < 0) {
        return -1;
    }
 
    if (zip_source_tell_write(za->src) < 0) {
        return -1;
    }
 
    return 0;
}

References _zip_cdir_write(), zip::src, za, and zip_source_tell_write().

Referenced by zip_close().

write_data_descriptor()

static int write_data_descriptor ( zip_t *  za, const zip_dirent_t *  dirent, int  is_zip64  )

static

Definition at line 683 of file zip_close.c.

                                                                       {
    zip_buffer_t *buffer = _zip_buffer_new(NULL, MAX_DATA_DESCRIPTOR_LENGTH);
    int ret = 0;
 
    if (buffer == NULL) {
        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
        return -1;
    }
 
    _zip_buffer_put(buffer, DATADES_MAGIC, 4);
    _zip_buffer_put_32(buffer, de->crc);
    if (is_zip64) {
        _zip_buffer_put_64(buffer, de->comp_size);
        _zip_buffer_put_64(buffer, de->uncomp_size);
    }
    else {
        _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
        _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
    }
 
    if (!_zip_buffer_ok(buffer)) {
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        ret = -1;
    }
    else {
        ret = _zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer));
    }
 
    _zip_buffer_free(buffer);
 
    return ret;
}

References _zip_buffer_data(), _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_offset(), _zip_buffer_ok(), _zip_buffer_put(), _zip_buffer_put_32(), _zip_buffer_put_64(), _zip_write(), zip_dirent::comp_size, zip_dirent::crc, DATADES_MAGIC, zip::error, MAX_DATA_DESCRIPTOR_LENGTH, NULL, zip_dirent::uncomp_size, za, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by add_data(), and zip_close().

zip_close()

ZIP_EXTERN int zip_close

(

zip_t *

za

)

Definition at line 52 of file zip_close.c.

                     {
    zip_uint64_t i, j, survivors, unchanged_offset;
    zip_int64_t off;
    int error;
    zip_filelist_t *filelist;
    int changed;
 
    if (za == NULL)
        return -1;
 
    changed = _zip_changed(za, &survivors);
 
    /* don't create zip files with no entries */
    if (survivors == 0) {
        if ((za->open_flags & ZIP_TRUNCATE) || changed) {
            if (zip_source_remove(za->src) < 0) {
                if (!((zip_error_code_zip(zip_source_error(za->src)) == ZIP_ER_REMOVE) && (zip_error_code_system(zip_source_error(za->src)) == ENOENT))) {
                    _zip_error_set_from_source(&za->error, za->src);
                    return -1;
                }
            }
        }
        zip_discard(za);
        return 0;
    }
 
    if (!changed) {
        zip_discard(za);
        return 0;
    }
 
    if (survivors > za->nentry) {
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
 
    if ((filelist = (zip_filelist_t *)malloc(sizeof(filelist[0]) * (size_t)survivors)) == NULL)
        return -1;
 
    unchanged_offset = ZIP_UINT64_MAX;
    /* create list of files with index into original archive  */
    for (i = j = 0; i < za->nentry; i++) {
        if (za->entry[i].orig != NULL && ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
            unchanged_offset = ZIP_MIN(unchanged_offset, za->entry[i].orig->offset);
        }
        if (za->entry[i].deleted) {
            continue;
        }
 
        if (j >= survivors) {
            free(filelist);
            zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
            return -1;
        }
 
        filelist[j].idx = i;
        j++;
    }
    if (j < survivors) {
        free(filelist);
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
 
    if ((zip_source_supports(za->src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING)) == 0) {
        unchanged_offset = 0;
    }
    else {
        if (unchanged_offset == ZIP_UINT64_MAX) {
            /* we're keeping all file data, find the end of the last one */
            zip_uint64_t last_index = ZIP_UINT64_MAX;
            unchanged_offset = 0;
 
            for (i = 0; i < za->nentry; i++) {
                if (za->entry[i].orig != NULL) {
                    if (za->entry[i].orig->offset >= unchanged_offset) {
                        unchanged_offset = za->entry[i].orig->offset;
                        last_index = i;
                    }
                }
            }
            if (last_index != ZIP_UINT64_MAX) {
                if ((unchanged_offset = _zip_file_get_end(za, last_index, &za->error)) == 0) {
                    free(filelist);
                    return -1;
                }
            }
        }
        if (unchanged_offset > 0) {
            if (zip_source_begin_write_cloning(za->src, unchanged_offset) < 0) {
                /* cloning not supported, need to copy everything */
                unchanged_offset = 0;
            }
        }
    }
    if (unchanged_offset == 0) {
        if (zip_source_begin_write(za->src) < 0) {
            _zip_error_set_from_source(&za->error, za->src);
            free(filelist);
            return -1;
        }
    }
 
    if (_zip_progress_start(za->progress) != 0) {
        zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
        zip_source_rollback_write(za->src);
        free(filelist);
        return -1;
    }
    error = 0;
    for (j = 0; j < survivors; j++) {
        int new_data;
        zip_entry_t *entry;
        zip_dirent_t *de;
 
        if (_zip_progress_subrange(za->progress, (double)j / (double)survivors, (double)(j + 1) / (double)survivors) != 0) {
            zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
            error = 1;
            break;
        }
 
        i = filelist[j].idx;
        entry = za->entry + i;
 
        if (entry->orig != NULL && entry->orig->offset < unchanged_offset) {
            /* already implicitly copied by cloning */
            continue;
        }
 
        new_data = (ZIP_ENTRY_DATA_CHANGED(entry) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_COMP_METHOD) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_ENCRYPTION_METHOD));
 
        /* create new local directory entry */
        if (entry->changes == NULL) {
            if ((entry->changes = _zip_dirent_clone(entry->orig)) == NULL) {
                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
                error = 1;
                break;
            }
        }
        de = entry->changes;
 
        if (_zip_read_local_ef(za, i) < 0) {
            error = 1;
            break;
        }
 
        if ((off = zip_source_tell_write(za->src)) < 0) {
            _zip_error_set_from_source(&za->error, za->src);
            error = 1;
            break;
        }
        de->offset = (zip_uint64_t)off;
 
        if (new_data) {
            zip_source_t *zs;
 
            zs = NULL;
            if (!ZIP_ENTRY_DATA_CHANGED(entry)) {
                if ((zs = _zip_source_zip_new(za, i, ZIP_FL_UNCHANGED, 0, 0, NULL, &za->error)) == NULL) {
                    error = 1;
                    break;
                }
            }
 
            /* add_data writes dirent */
            if (add_data(za, zs ? zs : entry->source, de, entry->changes ? entry->changes->changed : 0) < 0) {
                error = 1;
                if (zs)
                    zip_source_free(zs);
                break;
            }
            if (zs)
                zip_source_free(zs);
        }
        else {
            zip_uint64_t offset;
 
            if (de->encryption_method != ZIP_EM_TRAD_PKWARE) {
                /* when copying data, all sizes are known -> no data descriptor needed */
                /* except for PKWare encryption, where removing the data descriptor breaks password validation */
                de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
            }
            if (_zip_dirent_write(za, de, ZIP_FL_LOCAL) < 0) {
                error = 1;
                break;
            }
            if ((offset = _zip_file_get_offset(za, i, &za->error)) == 0) {
                error = 1;
                break;
            }
            if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
                _zip_error_set_from_source(&za->error, za->src);
                error = 1;
                break;
            }
            if (copy_data(za, de->comp_size) < 0) {
                error = 1;
                break;
            }
 
            if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
                if (write_data_descriptor(za, de, _zip_dirent_needs_zip64(de, 0)) < 0) {
                    error = 1;
                    break;
                }
            }
        }
    }
 
    if (!error) {
        if (write_cdir(za, filelist, survivors) < 0)
            error = 1;
    }
 
    free(filelist);
 
    if (!error) {
        if (zip_source_commit_write(za->src) != 0) {
            _zip_error_set_from_source(&za->error, za->src);
            error = 1;
        }
        _zip_progress_end(za->progress);
    }
 
    if (error) {
        zip_source_rollback_write(za->src);
        return -1;
    }
 
    zip_discard(za);
 
    return 0;
}

References _zip_changed(), _zip_dirent_clone(), _zip_dirent_needs_zip64(), _zip_dirent_write(), _zip_error_set_from_source(), _zip_file_get_end(), _zip_file_get_offset(), _zip_progress_end(), _zip_progress_start(), _zip_progress_subrange(), _zip_read_local_ef(), _zip_source_zip_new(), add_data(), zip_dirent::bitflags, zip_dirent::comp_size, copy_data(), zip_entry::deleted, zip_dirent::encryption_method, ENOENT, zip::entry, zip::error, error(), free(), i, zip_filelist::idx, malloc(), zip::nentry, NULL, off, zip_dirent::offset, zip::open_flags, zip_entry::orig, zip::progress, SEEK_SET, zip::src, write_cdir(), write_data_descriptor(), za, ZIP_DIRENT_COMP_METHOD, ZIP_DIRENT_ENCRYPTION_METHOD, zip_discard(), ZIP_EM_TRAD_PKWARE, ZIP_ENTRY_CHANGED, ZIP_ENTRY_DATA_CHANGED, ZIP_ENTRY_HAS_CHANGES, ZIP_ER_CANCELLED, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, ZIP_ER_REMOVE, zip_error_code_system(), zip_error_code_zip(), zip_error_set(), ZIP_FL_LOCAL, ZIP_FL_UNCHANGED, ZIP_GPBF_DATA_DESCRIPTOR, ZIP_MIN, zip_source_begin_write(), ZIP_SOURCE_BEGIN_WRITE_CLONING, zip_source_begin_write_cloning(), zip_source_commit_write(), zip_source_error(), zip_source_free(), ZIP_SOURCE_MAKE_COMMAND_BITMASK, zip_source_remove(), zip_source_rollback_write(), zip_source_seek(), zip_source_supports(), zip_source_tell_write(), ZIP_TRUNCATE, and ZIP_UINT64_MAX.

Referenced by add_from_zip(), compare_zip(), LLVMFuzzerTestOneInput(), main(), merge_zip(), rz_io_zip_alloc_zipfileobj(), rz_io_zip_flush_file(), rz_io_zip_get_by_file_idx(), rz_io_zip_get_files(), rz_io_zip_slurp_file(), and zin_close().