zip_extra_field.c File Reference

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

Go to the source code of this file.

Functions
zip_extra_field_t *	_zip_ef_clone (const zip_extra_field_t *ef, zip_error_t *error)
zip_extra_field_t *	_zip_ef_delete_by_id (zip_extra_field_t *ef, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags)
void	_zip_ef_free (zip_extra_field_t *ef)
const zip_uint8_t *	_zip_ef_get_by_id (const zip_extra_field_t *ef, zip_uint16_t *lenp, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags, zip_error_t *error)
zip_extra_field_t *	_zip_ef_merge (zip_extra_field_t *to, zip_extra_field_t *from)
zip_extra_field_t *	_zip_ef_new (zip_uint16_t id, zip_uint16_t size, const zip_uint8_t *data, zip_flags_t flags)
bool	_zip_ef_parse (const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags, zip_extra_field_t **ef_head_p, zip_error_t *error)
zip_extra_field_t *	_zip_ef_remove_internal (zip_extra_field_t *ef)
zip_uint16_t	_zip_ef_size (const zip_extra_field_t *ef, zip_flags_t flags)
int	_zip_ef_write (zip_t *za, const zip_extra_field_t *ef, zip_flags_t flags)
int	_zip_read_local_ef (zip_t *za, zip_uint64_t idx)

Function Documentation

_zip_ef_clone()

zip_extra_field_t* _zip_ef_clone	(	const zip_extra_field_t *	ef,
		zip_error_t *	error
	)

Definition at line 41 of file zip_extra_field.c.

                                                               {
    zip_extra_field_t *head, *prev, *def;
 
    head = prev = NULL;
 
    while (ef) {
        if ((def = _zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) {
            zip_error_set(error, ZIP_ER_MEMORY, 0);
            _zip_ef_free(head);
            return NULL;
        }
 
        if (head == NULL)
            head = def;
        if (prev)
            prev->next = def;
        prev = def;
 
        ef = ef->next;
    }
 
    return head;
}

References _zip_ef_free(), _zip_ef_new(), ef::data, def(), error(), ef::flags, test-lz4-versions::head, ef::id, zip_extra_field::next, NULL, ef::size, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_file_extra_field_prepare_for_change().

_zip_ef_delete_by_id()

zip_extra_field_t* _zip_ef_delete_by_id	(	zip_extra_field_t *	ef,
		zip_uint16_t	id,
		zip_uint16_t	id_idx,
		zip_flags_t	flags
	)

Definition at line 67 of file zip_extra_field.c.

                                                                                                     {
    zip_extra_field_t *head, *prev;
    int i;
 
    i = 0;
    head = ef;
    prev = NULL;
    for (; ef; ef = (prev ? prev->next : head)) {
        if ((ef->flags & flags & ZIP_EF_BOTH) && ((ef->id == id) || (id == ZIP_EXTRA_FIELD_ALL))) {
            if (id_idx == ZIP_EXTRA_FIELD_ALL || i == id_idx) {
                ef->flags &= ~(flags & ZIP_EF_BOTH);
                if ((ef->flags & ZIP_EF_BOTH) == 0) {
                    if (prev)
                        prev->next = ef->next;
                    else
                        head = ef->next;
                    ef->next = NULL;
                    _zip_ef_free(ef);
 
                    if (id_idx == ZIP_EXTRA_FIELD_ALL)
                        continue;
                }
            }
 
            i++;
            if (i > id_idx)
                break;
        }
        prev = ef;
    }
 
    return head;
}

References _zip_ef_free(), ef, flags, ef::flags, test-lz4-versions::head, i, id, ef::id, zip_extra_field::next, NULL, ZIP_EF_BOTH, and ZIP_EXTRA_FIELD_ALL.

Referenced by zip_file_extra_field_delete(), and zip_file_extra_field_delete_by_id().

_zip_ef_free()

void _zip_ef_free

(

zip_extra_field_t *

ef

)

Definition at line 103 of file zip_extra_field.c.

                                    {
    zip_extra_field_t *ef2;
 
    while (ef) {
        ef2 = ef->next;
        free(ef->data);
        free(ef);
        ef = ef2;
    }
}

References ef::data, and free().

Referenced by _zip_dirent_finalize(), _zip_dirent_write(), _zip_ef_clone(), _zip_ef_delete_by_id(), _zip_ef_merge(), _zip_ef_parse(), _zip_ef_remove_internal(), and zip_file_extra_field_set().

_zip_ef_get_by_id()

const zip_uint8_t* _zip_ef_get_by_id	(	const zip_extra_field_t *	ef,
		zip_uint16_t *	lenp,
		zip_uint16_t	id,
		zip_uint16_t	id_idx,
		zip_flags_t	flags,
		zip_error_t *	error
	)

Definition at line 116 of file zip_extra_field.c.

                                                                                                                                                {
    static const zip_uint8_t empty[1] = {'\0'};
 
    int i;
 
    i = 0;
    for (; ef; ef = ef->next) {
        if (ef->id == id && (ef->flags & flags & ZIP_EF_BOTH)) {
            if (i < id_idx) {
                i++;
                continue;
            }
 
            if (lenp)
                *lenp = ef->size;
            if (ef->size > 0)
                return ef->data;
            else
                return empty;
        }
    }
 
    zip_error_set(error, ZIP_ER_NOENT, 0);
    return NULL;
}

References ef::data, ef, error(), flags, ef::flags, i, ef::id, NULL, ef::size, ZIP_EF_BOTH, ZIP_ER_NOENT, and zip_error_set().

Referenced by _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_dirent_read(), and zip_file_extra_field_get_by_id().

_zip_ef_merge()

zip_extra_field_t* _zip_ef_merge	(	zip_extra_field_t *	to,
		zip_extra_field_t *	from
	)

Definition at line 144 of file zip_extra_field.c.

                                                              {
    zip_extra_field_t *ef2, *tt, *tail;
    int duplicate;
 
    if (to == NULL)
        return from;
 
    for (tail = to; tail->next; tail = tail->next)
        ;
 
    for (; from; from = ef2) {
        ef2 = from->next;
 
        duplicate = 0;
        for (tt = to; tt; tt = tt->next) {
            if (tt->id == from->id && tt->size == from->size && (tt->size == 0 || memcmp(tt->data, from->data, tt->size) == 0)) {
                tt->flags |= (from->flags & ZIP_EF_BOTH);
                duplicate = 1;
                break;
            }
        }
 
        from->next = NULL;
        if (duplicate)
            _zip_ef_free(from);
        else
            tail = tail->next = from;
    }
 
    return to;
}

References _zip_ef_free(), zip_extra_field::data, zip_extra_field::flags, from, zip_extra_field::id, zip_extra_field::next, NULL, zip_extra_field::size, to, and ZIP_EF_BOTH.

Referenced by _zip_checkcons(), and _zip_read_local_ef().

_zip_ef_new()

zip_extra_field_t* _zip_ef_new	(	zip_uint16_t	id,
		zip_uint16_t	size,
		const zip_uint8_t *	data,
		zip_flags_t	flags
	)

Definition at line 178 of file zip_extra_field.c.

                                                                                            {
    zip_extra_field_t *ef;
 
    if ((ef = (zip_extra_field_t *)malloc(sizeof(*ef))) == NULL)
        return NULL;
 
    ef->next = NULL;
    ef->flags = flags;
    ef->id = id;
    ef->size = size;
    if (size > 0) {
        if ((ef->data = (zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) {
            free(ef);
            return NULL;
        }
    }
    else
        ef->data = NULL;
 
    return ef;
}

References _zip_memdup(), ef::data, ef, flags, ef::flags, free(), id, ef::id, malloc(), NULL, and ef::size.

Referenced by _zip_dirent_write(), _zip_ef_clone(), _zip_ef_parse(), _zip_ef_utf8(), and zip_file_extra_field_set().

_zip_ef_parse()

bool _zip_ef_parse	(	const zip_uint8_t *	data,
		zip_uint16_t	len,
		zip_flags_t	flags,
		zip_extra_field_t **	ef_head_p,
		zip_error_t *	error
	)

Definition at line 202 of file zip_extra_field.c.

                                                                                                                               {
    zip_buffer_t *buffer;
    zip_extra_field_t *ef, *ef2, *ef_head;
 
    if ((buffer = _zip_buffer_new((zip_uint8_t *)data, len)) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return false;
    }
 
    ef_head = ef = NULL;
 
    while (_zip_buffer_ok(buffer) && _zip_buffer_left(buffer) >= 4) {
        zip_uint16_t fid, flen;
        zip_uint8_t *ef_data;
 
        fid = _zip_buffer_get_16(buffer);
        flen = _zip_buffer_get_16(buffer);
        ef_data = _zip_buffer_get(buffer, flen);
 
        if (ef_data == NULL) {
            zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_EF_LENGTH);
            _zip_buffer_free(buffer);
            _zip_ef_free(ef_head);
            return false;
        }
 
        if ((ef2 = _zip_ef_new(fid, flen, ef_data, flags)) == NULL) {
            zip_error_set(error, ZIP_ER_MEMORY, 0);
            _zip_buffer_free(buffer);
            _zip_ef_free(ef_head);
            return false;
        }
 
        if (ef_head) {
            ef->next = ef2;
            ef = ef2;
        }
        else
            ef_head = ef = ef2;
    }
 
    if (!_zip_buffer_eof(buffer)) {
        /* Android APK files align stored file data with padding in extra fields; ignore. */
        /* see https://android.googlesource.com/platform/build/+/master/tools/zipalign/ZipAlign.cpp */
        size_t glen = _zip_buffer_left(buffer);
        zip_uint8_t *garbage;
        garbage = _zip_buffer_get(buffer, glen);
        if (glen >= 4 || garbage == NULL || memcmp(garbage, "\0\0\0", glen) != 0) {
            zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EF_TRAILING_GARBAGE);
            _zip_buffer_free(buffer);
            _zip_ef_free(ef_head);
            return false;
        }
    }
 
    _zip_buffer_free(buffer);
 
    if (ef_head_p) {
        *ef_head_p = ef_head;
    }
    else {
        _zip_ef_free(ef_head);
    }
 
    return true;
}

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_left(), _zip_buffer_new(), _zip_buffer_ok(), _zip_ef_free(), _zip_ef_new(), ef, error(), flags, len, NULL, ZIP_ER_DETAIL_EF_TRAILING_GARBAGE, ZIP_ER_DETAIL_INVALID_EF_LENGTH, ZIP_ER_INCONS, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_dirent_read(), and _zip_read_local_ef().

_zip_ef_remove_internal()

zip_extra_field_t* _zip_ef_remove_internal

(

zip_extra_field_t *

ef

)

Definition at line 271 of file zip_extra_field.c.

                                               {
    zip_extra_field_t *ef_head;
    zip_extra_field_t *prev, *next;
 
    ef_head = ef;
    prev = NULL;
 
    while (ef) {
        if (ZIP_EF_IS_INTERNAL(ef->id)) {
            next = ef->next;
            if (ef_head == ef)
                ef_head = next;
            ef->next = NULL;
            _zip_ef_free(ef);
            if (prev)
                prev->next = next;
            ef = next;
        }
        else {
            prev = ef;
            ef = ef->next;
        }
    }
 
    return ef_head;
}

References _zip_ef_free(), ef, ef::id, zip_extra_field::next, NULL, and ZIP_EF_IS_INTERNAL.

Referenced by _zip_dirent_read(), and _zip_read_local_ef().

_zip_ef_size()

zip_uint16_t _zip_ef_size	(	const zip_extra_field_t *	ef,
		zip_flags_t	flags
	)

Definition at line 300 of file zip_extra_field.c.

                                                             {
    zip_uint16_t size;
 
    size = 0;
    for (; ef; ef = ef->next) {
        if (ef->flags & flags & ZIP_EF_BOTH)
            size = (zip_uint16_t)(size + 4 + ef->size);
    }
 
    return size;
}

References ef, flags, ef::flags, ef::size, and ZIP_EF_BOTH.

Referenced by _zip_dirent_write(), and zip_file_extra_field_set().

_zip_ef_write()

int _zip_ef_write	(	zip_t *	za,
		const zip_extra_field_t *	ef,
		zip_flags_t	flags
	)

Definition at line 314 of file zip_extra_field.c.

                                                                         {
    zip_uint8_t b[4];
    zip_buffer_t *buffer = _zip_buffer_new(b, sizeof(b));
 
    if (buffer == NULL) {
        return -1;
    }
 
    for (; ef; ef = ef->next) {
        if (ef->flags & flags & ZIP_EF_BOTH) {
            _zip_buffer_set_offset(buffer, 0);
            _zip_buffer_put_16(buffer, ef->id);
            _zip_buffer_put_16(buffer, ef->size);
            if (!_zip_buffer_ok(buffer)) {
                zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
                _zip_buffer_free(buffer);
                return -1;
            }
            if (_zip_write(za, b, 4) < 0) {
                _zip_buffer_free(buffer);
                return -1;
            }
            if (ef->size > 0) {
                if (_zip_write(za, ef->data, ef->size) < 0) {
                    _zip_buffer_free(buffer);
                    return -1;
                }
            }
        }
    }
 
    _zip_buffer_free(buffer);
    return 0;
}

References _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_ok(), _zip_buffer_put_16(), _zip_buffer_set_offset(), _zip_write(), b, ef::data, ef, zip::error, flags, ef::flags, ef::id, NULL, ef::size, za, ZIP_EF_BOTH, ZIP_ER_INTERNAL, and zip_error_set().

Referenced by _zip_dirent_write().

_zip_read_local_ef()

int _zip_read_local_ef	(	zip_t *	za,
		zip_uint64_t	idx
	)

Definition at line 351 of file zip_extra_field.c.

                                                {
    zip_entry_t *e;
    unsigned char b[4];
    zip_buffer_t *buffer;
    zip_uint16_t fname_len, ef_len;
 
    if (idx >= za->nentry) {
        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
        return -1;
    }
 
    e = za->entry + idx;
 
    if (e->orig == NULL || e->orig->local_extra_fields_read)
        return 0;
 
    if (e->orig->offset + 26 > ZIP_INT64_MAX) {
        zip_error_set(&za->error, ZIP_ER_SEEK, EFBIG);
        return -1;
    }
 
    if (zip_source_seek(za->src, (zip_int64_t)(e->orig->offset + 26), SEEK_SET) < 0) {
        _zip_error_set_from_source(&za->error, za->src);
        return -1;
    }
 
    if ((buffer = _zip_buffer_new_from_source(za->src, sizeof(b), b, &za->error)) == NULL) {
        return -1;
    }
 
    fname_len = _zip_buffer_get_16(buffer);
    ef_len = _zip_buffer_get_16(buffer);
 
    if (!_zip_buffer_eof(buffer)) {
        _zip_buffer_free(buffer);
        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
        return -1;
    }
 
    _zip_buffer_free(buffer);
 
    if (ef_len > 0) {
        zip_extra_field_t *ef;
        zip_uint8_t *ef_raw;
 
        if (zip_source_seek(za->src, fname_len, SEEK_CUR) < 0) {
            zip_error_set(&za->error, ZIP_ER_SEEK, errno);
            return -1;
        }
 
        ef_raw = _zip_read_data(NULL, za->src, ef_len, 0, &za->error);
 
        if (ef_raw == NULL)
            return -1;
 
        if (!_zip_ef_parse(ef_raw, ef_len, ZIP_EF_LOCAL, &ef, &za->error)) {
            free(ef_raw);
            return -1;
        }
        free(ef_raw);
 
        if (ef) {
            ef = _zip_ef_remove_internal(ef);
            e->orig->extra_fields = _zip_ef_merge(e->orig->extra_fields, ef);
        }
    }
 
    e->orig->local_extra_fields_read = 1;
 
    if (e->changes && e->changes->local_extra_fields_read == 0) {
        e->changes->extra_fields = e->orig->extra_fields;
        e->changes->local_extra_fields_read = 1;
    }
 
    return 0;
}

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get_16(), _zip_buffer_new_from_source(), _zip_ef_merge(), _zip_ef_parse(), _zip_ef_remove_internal(), _zip_error_set_from_source(), _zip_read_data(), b, e, ef, EFBIG, zip::entry, zip::error, free(), setup::idx, zip::nentry, NULL, SEEK_CUR, SEEK_SET, zip::src, za, ZIP_EF_LOCAL, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_SEEK, zip_error_set(), ZIP_INT64_MAX, and zip_source_seek().

Referenced by _zip_file_extra_field_prepare_for_change(), zip_close(), zip_file_extra_field_get(), zip_file_extra_field_get_by_id(), zip_file_extra_fields_count(), and zip_file_extra_fields_count_by_id().