zip_source_zip_new.c File Reference

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

Go to the source code of this file.

Functions
static void	_zip_file_attributes_from_dirent (zip_file_attributes_t *attributes, zip_dirent_t *de)
zip_source_t *	_zip_source_zip_new (zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags, zip_uint64_t start, zip_uint64_t len, const char *password, zip_error_t *error)

Function Documentation

_zip_file_attributes_from_dirent()

static void _zip_file_attributes_from_dirent ( zip_file_attributes_t *  attributes, zip_dirent_t *  de  )

static

Definition at line 182 of file zip_source_zip_new.c.

                                                                                      {
    zip_file_attributes_init(attributes);
    attributes->valid = ZIP_FILE_ATTRIBUTES_ASCII | ZIP_FILE_ATTRIBUTES_HOST_SYSTEM | ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
    attributes->ascii = de->int_attrib & 1;
    attributes->host_system = de->version_madeby >> 8;
    attributes->external_file_attributes = de->ext_attrib;
    attributes->general_purpose_bit_flags = de->bitflags;
    attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
}

References zip_file_attributes::ascii, zip_dirent::bitflags, zip_dirent::ext_attrib, zip_file_attributes::external_file_attributes, zip_file_attributes::general_purpose_bit_flags, zip_file_attributes::general_purpose_bit_mask, zip_file_attributes::host_system, zip_dirent::int_attrib, zip_file_attributes::valid, zip_dirent::version_madeby, ZIP_FILE_ATTRIBUTES_ASCII, ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES, ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS, ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK, ZIP_FILE_ATTRIBUTES_HOST_SYSTEM, and zip_file_attributes_init().

Referenced by _zip_source_zip_new().

_zip_source_zip_new()

zip_source_t* _zip_source_zip_new	(	zip_t *	srcza,
		zip_uint64_t	srcidx,
		zip_flags_t	flags,
		zip_uint64_t	start,
		zip_uint64_t	len,
		const char *	password,
		zip_error_t *	error
	)

Definition at line 41 of file zip_source_zip_new.c.

                                                                                                                                                                        {
    zip_source_t *src, *s2;
    zip_stat_t st;
    zip_file_attributes_t attributes;
    zip_dirent_t *de;
    bool partial_data, needs_crc, needs_decrypt, needs_decompress;
 
    if (srcza == NULL || srcidx >= srcza->nentry || len > ZIP_INT64_MAX) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if ((flags & ZIP_FL_UNCHANGED) == 0 && (ZIP_ENTRY_DATA_CHANGED(srcza->entry + srcidx) || srcza->entry[srcidx].deleted)) {
        zip_error_set(error, ZIP_ER_CHANGED, 0);
        return NULL;
    }
 
    if (zip_stat_index(srcza, srcidx, flags | ZIP_FL_UNCHANGED, &st) < 0) {
        zip_error_set(error, ZIP_ER_INTERNAL, 0);
        return NULL;
    }
 
    if (flags & ZIP_FL_ENCRYPTED) {
        flags |= ZIP_FL_COMPRESSED;
    }
 
    if ((start > 0 || len > 0) && (flags & ZIP_FL_COMPRESSED)) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    /* overflow or past end of file */
    if ((start > 0 || len > 0) && (start + len < start || start + len > st.size)) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if (len == 0) {
        len = st.size - start;
    }
 
    partial_data = len < st.size;
    needs_decrypt = ((flags & ZIP_FL_ENCRYPTED) == 0) && (st.encryption_method != ZIP_EM_NONE);
    needs_decompress = ((flags & ZIP_FL_COMPRESSED) == 0) && (st.comp_method != ZIP_CM_STORE);
    /* when reading the whole file, check for CRC errors */
    needs_crc = ((flags & ZIP_FL_COMPRESSED) == 0 || st.comp_method == ZIP_CM_STORE) && !partial_data;
 
    if (needs_decrypt) {
        if (password == NULL) {
            password = srcza->default_password;
        }
        if (password == NULL) {
            zip_error_set(error, ZIP_ER_NOPASSWD, 0);
            return NULL;
        }
    }
 
    if ((de = _zip_get_dirent(srcza, srcidx, flags, error)) == NULL) {
        return NULL;
    }
    _zip_file_attributes_from_dirent(&attributes, de);
 
    if (st.comp_size == 0) {
        return zip_source_buffer_with_attributes_create(NULL, 0, 0, &attributes, error);
    }
 
    if (partial_data && !needs_decrypt && !needs_decompress) {
        struct zip_stat st2;
 
        st2.size = len;
        st2.comp_size = len;
        st2.comp_method = ZIP_CM_STORE;
        st2.mtime = st.mtime;
        st2.valid = ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_MTIME;
 
        if ((src = _zip_source_window_new(srcza->src, start, (zip_int64_t)len, &st2, &attributes, srcza, srcidx, error)) == NULL) {
            return NULL;
        }
    }
    else {
        if (st.comp_size > ZIP_INT64_MAX) {
            zip_error_set(error, ZIP_ER_INVAL, 0);
            return NULL;
        }
        if ((src =  _zip_source_window_new(srcza->src, 0, (zip_int64_t)st.comp_size, &st, &attributes, srcza, srcidx, error)) == NULL) {
            return NULL;
        }
    }
 
    if (_zip_source_set_source_archive(src, srcza) < 0) {
        zip_source_free(src);
        return NULL;
    }
 
    /* creating a layered source calls zip_keep() on the lower layer, so we free it */
 
    if (needs_decrypt) {
        zip_encryption_implementation enc_impl;
 
        if ((enc_impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
            zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
            return NULL;
        }
 
        s2 = enc_impl(srcza, src, st.encryption_method, 0, password);
        zip_source_free(src);
        if (s2 == NULL) {
            return NULL;
        }
        src = s2;
    }
    if (needs_decompress) {
        s2 = zip_source_decompress(srcza, src, st.comp_method);
        zip_source_free(src);
        if (s2 == NULL) {
            return NULL;
        }
        src = s2;
    }
    if (needs_crc) {
        s2 = zip_source_crc_create(src, 1, error);
        zip_source_free(src);
        if (s2 == NULL) {
            return NULL;
        }
        src = s2;
    }
 
    if (partial_data && (needs_decrypt || needs_decompress)) {
        s2 = zip_source_window_create(src, start, (zip_int64_t)len, error);
        zip_source_free(src);
        if (s2 == NULL) {
            return NULL;
        }
        src = s2;
    }
 
    return src;
}

References _zip_file_attributes_from_dirent(), _zip_get_dirent(), _zip_get_encryption_implementation(), _zip_source_set_source_archive(), _zip_source_window_new(), zip_stat::comp_method, zip_stat::comp_size, zip::default_password, zip_entry::deleted, zip_stat::encryption_method, zip::entry, error(), flags, len, zip_stat::mtime, zip::nentry, NULL, s2, zip_stat::size, zip::src, src, start, zip_stat::valid, ZIP_CM_STORE, ZIP_CODEC_DECODE, ZIP_EM_NONE, ZIP_ENTRY_DATA_CHANGED, ZIP_ER_CHANGED, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_NOPASSWD, zip_error_set(), ZIP_FL_COMPRESSED, ZIP_FL_ENCRYPTED, ZIP_FL_UNCHANGED, ZIP_INT64_MAX, zip_source_buffer_with_attributes_create(), zip_source_crc_create(), zip_source_decompress(), zip_source_free(), zip_source_window_create(), ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, zip_stat_index(), ZIP_STAT_MTIME, and ZIP_STAT_SIZE.

Referenced by zip_close(), zip_fopen_index_encrypted(), and zip_source_zip_create().