zip_source_buffer.c File Reference

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

Go to the source code of this file.

Classes
struct	buffer
struct	read_data

Macros
#define	WRITE_FRAGMENT_SIZE   (64 * 1024)
#define	buffer_capacity(buffer)   ((buffer)->fragment_offsets[(buffer)->nfragments])
#define	buffer_size(buffer)   ((buffer)->size)

Typedefs
typedef struct buffer	buffer_t

Functions
static buffer_t *	buffer_clone (buffer_t *buffer, zip_uint64_t length, zip_error_t *error)
static zip_uint64_t	buffer_find_fragment (const buffer_t *buffer, zip_uint64_t offset)
static void	buffer_free (buffer_t *buffer)
static bool	buffer_grow_fragments (buffer_t *buffer, zip_uint64_t capacity, zip_error_t *error)
static buffer_t *	buffer_new (const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int free_data, zip_error_t *error)
static zip_int64_t	buffer_read (buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length)
static int	buffer_seek (buffer_t *buffer, void *data, zip_uint64_t len, zip_error_t *error)
static zip_int64_t	buffer_write (buffer_t *buffer, const zip_uint8_t *data, zip_uint64_t length, zip_error_t *)
static zip_int64_t	read_data (void *, void *, zip_uint64_t, zip_source_cmd_t)
zip_source_t *	zip_source_buffer_with_attributes_create (const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes, zip_error_t *error)
zip_source_t *	zip_source_buffer_fragment_with_attributes_create (const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep, zip_file_attributes_t *attributes, zip_error_t *error)
ZIP_EXTERN zip_source_t *	zip_source_buffer (zip_t *za, const void *data, zip_uint64_t len, int freep)
ZIP_EXTERN zip_source_t *	zip_source_buffer_create (const void *data, zip_uint64_t len, int freep, zip_error_t *error)
ZIP_EXTERN zip_source_t *	zip_source_buffer_fragment (zip_t *za, const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep)
ZIP_EXTERN zip_source_t *	zip_source_buffer_fragment_create (const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep, zip_error_t *error)
zip_source_t *	zip_source_buffer_with_attributes (zip_t *za, const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes)

Macro Definition Documentation

buffer_capacity

#define buffer_capacity

(

buffer

)

((buffer)->fragment_offsets[(buffer)->nfragments])

Definition at line 69 of file zip_source_buffer.c.

buffer_size

#define buffer_size

(

buffer

)

((buffer)->size)

Definition at line 70 of file zip_source_buffer.c.

WRITE_FRAGMENT_SIZE

#define WRITE_FRAGMENT_SIZE   (64 * 1024)

Definition at line 40 of file zip_source_buffer.c.

Typedef Documentation

buffer_t

typedef struct buffer buffer_t

Definition at line 1 of file zip_source_buffer.c.

Function Documentation

buffer_clone()

static buffer_t * buffer_clone ( buffer_t *  buffer, zip_uint64_t  length, zip_error_t *  error  )

static

Definition at line 322 of file zip_source_buffer.c.

                                                                        {
    zip_uint64_t fragment, fragment_offset, waste;
    buffer_t *clone;
 
    if (offset == 0) {
        return buffer_new(NULL, 0, 1, error);
    }
 
    if (offset > buffer->size) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
    if (buffer->shared_buffer != NULL) {
        zip_error_set(error, ZIP_ER_INUSE, 0);
        return NULL;
    }
 
    fragment = buffer_find_fragment(buffer, offset);
    fragment_offset = offset - buffer->fragment_offsets[fragment];
 
    if (fragment_offset == 0) {
        fragment--;
        fragment_offset = buffer->fragments[fragment].length;
    }
 
    waste = buffer->fragments[fragment].length - fragment_offset;
    if (waste > offset) {
        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
        return NULL;
    }
 
    if ((clone = buffer_new(buffer->fragments, fragment + 1, 0, error)) == NULL) {
        return NULL;
    }
 
#ifndef __clang_analyzer__
    /* clone->fragments can't be null, since it was created with at least one fragment */
    clone->fragments[clone->nfragments - 1].length = fragment_offset;
#endif
    clone->fragment_offsets[clone->nfragments] = offset;
    clone->size = offset;
 
    clone->first_owned_fragment = ZIP_MIN(buffer->first_owned_fragment, clone->nfragments);
 
    buffer->shared_buffer = clone;
    clone->shared_buffer = buffer;
    buffer->shared_fragments = clone->nfragments;
    clone->shared_fragments = fragment + 1;
    
    return clone;
}

References buffer_find_fragment(), buffer_new(), error(), buffer::first_owned_fragment, buffer::fragment_offsets, buffer::fragments, zip_buffer_fragment::length, buffer::nfragments, NULL, buffer::shared_buffer, buffer::shared_fragments, buffer::size, ZIP_ER_INUSE, ZIP_ER_INVAL, ZIP_ER_OPNOTSUPP, zip_error_set(), and ZIP_MIN.

Referenced by read_data().

buffer_find_fragment()

static zip_uint64_t buffer_find_fragment ( const buffer_t *  buffer, zip_uint64_t  offset  )

static

Definition at line 376 of file zip_source_buffer.c.

                                                                  {
    zip_uint64_t low, high, mid;
 
    if (buffer->nfragments == 0) {
        return 0;
    }
 
    low = 0;
    high = buffer->nfragments - 1;
 
    while (low < high) {
        mid = (high - low) / 2 + low;
        if (buffer->fragment_offsets[mid] > offset) {
            high = mid - 1;
        }
        else if (mid == buffer->nfragments || buffer->fragment_offsets[mid + 1] > offset) {
            return mid;
        }
        else {
            low = mid + 1;
        }
    }
 
    return low;
}

References buffer::fragment_offsets, and buffer::nfragments.

Referenced by buffer_clone(), and buffer_seek().

buffer_free()

static void buffer_free ( buffer_t *  buffer )

static

Definition at line 404 of file zip_source_buffer.c.

                              {
    zip_uint64_t i;
 
    if (buffer == NULL) {
        return;
    }
 
    if (buffer->shared_buffer != NULL) {
        buffer->shared_buffer->shared_buffer = NULL;
        buffer->shared_buffer->shared_fragments = 0;
 
        buffer->first_owned_fragment = ZIP_MAX(buffer->first_owned_fragment, buffer->shared_fragments);
    }
 
    for (i = buffer->first_owned_fragment; i < buffer->nfragments; i++) {
        free(buffer->fragments[i].data);
    }
    free(buffer->fragments);
    free(buffer->fragment_offsets);
    free(buffer);
}

References zip_buffer_fragment::data, buffer::first_owned_fragment, buffer::fragment_offsets, buffer::fragments, free(), i, NULL, buffer::shared_buffer, buffer::shared_fragments, and ZIP_MAX.

Referenced by buffer_new(), read_data(), and zip_source_buffer_fragment_with_attributes_create().

buffer_grow_fragments()

static bool buffer_grow_fragments ( buffer_t *  buffer, zip_uint64_t  capacity, zip_error_t *  error  )

static

Definition at line 428 of file zip_source_buffer.c.

                                                                                   {
    zip_buffer_fragment_t *fragments;
    zip_uint64_t *offsets;
 
    if (capacity < buffer->fragments_capacity) {
        return true;
    }
 
    if ((fragments = realloc(buffer->fragments, sizeof(buffer->fragments[0]) * capacity)) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return false;
    }
    buffer->fragments = fragments;
    if ((offsets = realloc(buffer->fragment_offsets, sizeof(buffer->fragment_offsets[0]) * (capacity + 1))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        return false;
    }
    buffer->fragment_offsets = offsets;
    buffer->fragments_capacity = capacity;
 
    return true;
}

References error(), buffer::fragment_offsets, buffer::fragments, buffer::fragments_capacity, NULL, realloc(), ZIP_ER_MEMORY, and zip_error_set().

Referenced by buffer_new(), and buffer_write().

buffer_new()

static buffer_t * buffer_new ( const zip_buffer_fragment_t *  fragments, zip_uint64_t  nfragments, int  free_data, zip_error_t *  error  )

static

Definition at line 453 of file zip_source_buffer.c.

                                                                                                               {
    buffer_t *buffer;
 
    if ((buffer = malloc(sizeof(*buffer))) == NULL) {
        return NULL;
    }
 
    buffer->offset = 0;
    buffer->first_owned_fragment = 0;
    buffer->size = 0;
    buffer->fragments = NULL;
    buffer->fragment_offsets = NULL;
    buffer->nfragments = 0;
    buffer->fragments_capacity = 0;
    buffer->shared_buffer = NULL;
    buffer->shared_fragments = 0;
 
    if (nfragments == 0) {
        if ((buffer->fragment_offsets = malloc(sizeof(buffer->fragment_offsets[0]))) == NULL) {
            free(buffer);
            zip_error_set(error, ZIP_ER_MEMORY, 0);
            return NULL;
        }
        buffer->fragment_offsets[0] = 0;
    }
    else {
        zip_uint64_t i, j, offset;
 
        if (!buffer_grow_fragments(buffer, nfragments, NULL)) {
            zip_error_set(error, ZIP_ER_MEMORY, 0);
            buffer_free(buffer);
            return NULL;
        }
 
        offset = 0;
        for (i = 0, j = 0; i < nfragments; i++) {
            if (fragments[i].length == 0) {
                continue;
            }
            if (fragments[i].data == NULL) {
                zip_error_set(error, ZIP_ER_INVAL, 0);
                buffer_free(buffer);
                return NULL;
            }
            buffer->fragments[j].data = fragments[i].data;
            buffer->fragments[j].length = fragments[i].length;
            buffer->fragment_offsets[i] = offset;
            offset += fragments[i].length;
            j++;
        }
        buffer->nfragments = j;
        buffer->first_owned_fragment = free_data ? 0 : buffer->nfragments;
        buffer->fragment_offsets[buffer->nfragments] = offset;
        buffer->size = offset;
    }
 
    return buffer;
}

References buffer_free(), buffer_grow_fragments(), zip_buffer_fragment::data, error(), buffer::first_owned_fragment, buffer::fragment_offsets, buffer::fragments, buffer::fragments_capacity, free(), i, length, zip_buffer_fragment::length, malloc(), buffer::nfragments, NULL, buffer::offset, buffer::shared_buffer, buffer::shared_fragments, buffer::size, ZIP_ER_INVAL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by buffer_clone(), read_data(), and zip_source_buffer_fragment_with_attributes_create().

buffer_read()

static zip_int64_t buffer_read ( buffer_t *  buffer, zip_uint8_t *  data, zip_uint64_t  length  )

static

Definition at line 513 of file zip_source_buffer.c.

                                                                      {
    zip_uint64_t n, i, fragment_offset;
 
    length = ZIP_MIN(length, buffer->size - buffer->offset);
 
    if (length == 0) {
        return 0;
    }
    if (length > ZIP_INT64_MAX) {
        return -1;
    }
 
    i = buffer->current_fragment;
    fragment_offset = buffer->offset - buffer->fragment_offsets[i];
    n = 0;
    while (n < length) {
        zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
 
        memcpy(data + n, buffer->fragments[i].data + fragment_offset, left);
 
        if (left == buffer->fragments[i].length - fragment_offset) {
            i++;
        }
        n += left;
        fragment_offset = 0;
    }
 
    buffer->offset += n;
    buffer->current_fragment = i;
    return (zip_int64_t)n;
}

References buffer::current_fragment, zip_buffer_fragment::data, buffer::fragment_offsets, buffer::fragments, i, length, zip_buffer_fragment::length, memcpy(), n, buffer::offset, buffer::size, ZIP_INT64_MAX, and ZIP_MIN.

Referenced by read_data().

buffer_seek()

static int buffer_seek ( buffer_t *  buffer, void *  data, zip_uint64_t  len, zip_error_t *  error  )

static

Definition at line 547 of file zip_source_buffer.c.

                                                                                {
    zip_int64_t new_offset = zip_source_seek_compute_offset(buffer->offset, buffer->size, data, len, error);
 
    if (new_offset < 0) {
        return -1;
    }
 
    buffer->offset = (zip_uint64_t)new_offset;
    buffer->current_fragment = buffer_find_fragment(buffer, buffer->offset);
    return 0;
}

References buffer_find_fragment(), buffer::current_fragment, error(), len, buffer::offset, buffer::size, and zip_source_seek_compute_offset().

Referenced by read_data().

buffer_write()

static zip_int64_t buffer_write ( buffer_t *  buffer, const zip_uint8_t *  data, zip_uint64_t  length, zip_error_t *  error  )

static

Definition at line 561 of file zip_source_buffer.c.

                                                                                                 {
    zip_uint64_t n, i, fragment_offset, capacity;
 
    if (buffer->offset + length + WRITE_FRAGMENT_SIZE - 1 < length) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return -1;
    }
 
    /* grow buffer if needed */
    capacity = buffer_capacity(buffer);
    if (buffer->offset + length > capacity) {
        zip_uint64_t needed_fragments = buffer->nfragments + (length - (capacity - buffer->offset) + WRITE_FRAGMENT_SIZE - 1) / WRITE_FRAGMENT_SIZE;
 
        if (needed_fragments > buffer->fragments_capacity) {
            zip_uint64_t new_capacity = buffer->fragments_capacity;
 
            if (new_capacity == 0) {
                new_capacity = 16;
            }
            while (new_capacity < needed_fragments) {
                new_capacity *= 2;
            }
 
            if (!buffer_grow_fragments(buffer, new_capacity, error)) {
                zip_error_set(error, ZIP_ER_MEMORY, 0);
                return -1;
            }
        }
 
        while (buffer->nfragments < needed_fragments) {
            if ((buffer->fragments[buffer->nfragments].data = malloc(WRITE_FRAGMENT_SIZE)) == NULL) {
                zip_error_set(error, ZIP_ER_MEMORY, 0);
                return -1;
            }
            buffer->fragments[buffer->nfragments].length = WRITE_FRAGMENT_SIZE;
            buffer->nfragments++;
            capacity += WRITE_FRAGMENT_SIZE;
            buffer->fragment_offsets[buffer->nfragments] = capacity;
        }
    }
 
    i = buffer->current_fragment;
    fragment_offset = buffer->offset - buffer->fragment_offsets[i];
    n = 0;
    while (n < length) {
        zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
 
        memcpy(buffer->fragments[i].data + fragment_offset, data + n, left);
 
        if (left == buffer->fragments[i].length - fragment_offset) {
            i++;
        }
        n += left;
        fragment_offset = 0;
    }
 
    buffer->offset += n;
    buffer->current_fragment = i;
    if (buffer->offset > buffer->size) {
        buffer->size = buffer->offset;
    }
 
    return (zip_int64_t)n;
}

References buffer_capacity, buffer_grow_fragments(), buffer::current_fragment, zip_buffer_fragment::data, error(), buffer::fragment_offsets, buffer::fragments, buffer::fragments_capacity, i, length, zip_buffer_fragment::length, malloc(), memcpy(), n, buffer::nfragments, NULL, buffer::offset, buffer::size, WRITE_FRAGMENT_SIZE, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_set(), and ZIP_MIN.

Referenced by read_data().

read_data()

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

static

Definition at line 185 of file zip_source_buffer.c.

                                                                           {
    struct read_data *ctx = (struct read_data *)state;
 
    switch (cmd) {
    case ZIP_SOURCE_BEGIN_WRITE:
        if ((ctx->out = buffer_new(NULL, 0, 0, &ctx->error)) == NULL) {
            return -1;
        }
        ctx->out->offset = 0;
        ctx->out->current_fragment = 0;
        return 0;
 
    case ZIP_SOURCE_BEGIN_WRITE_CLONING:
        if ((ctx->out = buffer_clone(ctx->in, len, &ctx->error)) == NULL) {
            return -1;
        }
        ctx->out->offset = len;
        ctx->out->current_fragment = ctx->out->nfragments;
        return 0;
 
    case ZIP_SOURCE_CLOSE:
        return 0;
 
    case ZIP_SOURCE_COMMIT_WRITE:
        buffer_free(ctx->in);
        ctx->in = ctx->out;
        ctx->out = NULL;
        return 0;
 
    case ZIP_SOURCE_ERROR:
        return zip_error_to_data(&ctx->error, data, len);
 
    case ZIP_SOURCE_FREE:
        buffer_free(ctx->in);
        buffer_free(ctx->out);
        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;
        }
 
        memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
 
        return sizeof(ctx->attributes);
    }
 
    case ZIP_SOURCE_OPEN:
        ctx->in->offset = 0;
        ctx->in->current_fragment = 0;
        return 0;
 
    case ZIP_SOURCE_READ:
        if (len > ZIP_INT64_MAX) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
        return buffer_read(ctx->in, data, len);
 
    case ZIP_SOURCE_REMOVE: {
        buffer_t *empty = buffer_new(NULL, 0, 0, &ctx->error);
        if (empty == NULL) {
            return -1;
        }
 
        buffer_free(ctx->in);
        ctx->in = empty;
        return 0;
    }
 
    case ZIP_SOURCE_ROLLBACK_WRITE:
        buffer_free(ctx->out);
        ctx->out = NULL;
        return 0;
 
    case ZIP_SOURCE_SEEK:
        return buffer_seek(ctx->in, data, len, &ctx->error);
 
    case ZIP_SOURCE_SEEK_WRITE:
        return buffer_seek(ctx->out, data, len, &ctx->error);
 
    case ZIP_SOURCE_STAT: {
        zip_stat_t *st;
 
        if (len < sizeof(*st)) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
 
        st = (zip_stat_t *)data;
 
        zip_stat_init(st);
        st->mtime = ctx->mtime;
        st->size = ctx->in->size;
        st->comp_size = st->size;
        st->comp_method = ZIP_CM_STORE;
        st->encryption_method = ZIP_EM_NONE;
        st->valid = ZIP_STAT_MTIME | ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
 
        return sizeof(*st);
    }
 
    case ZIP_SOURCE_SUPPORTS:
        return zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_BEGIN_WRITE_CLONING, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, -1);
 
    case ZIP_SOURCE_TELL:
        if (ctx->in->offset > ZIP_INT64_MAX) {
            zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
            return -1;
        }
        return (zip_int64_t)ctx->in->offset;
 
 
    case ZIP_SOURCE_TELL_WRITE:
        if (ctx->out->offset > ZIP_INT64_MAX) {
            zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
            return -1;
        }
        return (zip_int64_t)ctx->out->offset;
 
    case ZIP_SOURCE_WRITE:
        if (len > ZIP_INT64_MAX) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
        return buffer_write(ctx->out, data, len, &ctx->error);
 
    default:
        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
        return -1;
    }
}

References buffer_clone(), buffer_free(), buffer_new(), buffer_read(), buffer_seek(), buffer_write(), cmd, zip_stat::comp_method, zip_stat::comp_size, zip_stat::encryption_method, EOVERFLOW, ctx::error, free(), ctx::in, len, memcpy(), zip_stat::mtime, NULL, ctx::out, zip_stat::size, zip_stat::valid, ZIP_CM_STORE, ZIP_EM_NONE, ZIP_ER_INVAL, ZIP_ER_OPNOTSUPP, ZIP_ER_TELL, zip_error_set(), zip_error_to_data(), ZIP_INT64_MAX, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_BEGIN_WRITE_CLONING, ZIP_SOURCE_CLOSE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, zip_source_make_command_bitmap(), ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_STAT, ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, ZIP_STAT_ENCRYPTION_METHOD, zip_stat_init(), ZIP_STAT_MTIME, and ZIP_STAT_SIZE.

zip_source_buffer()

ZIP_EXTERN zip_source_t* zip_source_buffer	(	zip_t *	za,
		const void *	data,
		zip_uint64_t	len,
		int	freep
	)

Definition at line 88 of file zip_source_buffer.c.

                                                                            {
    if (za == NULL)
        return NULL;
 
    return zip_source_buffer_with_attributes_create(data, len, freep, NULL, &za->error);
}

References zip::error, len, NULL, za, and zip_source_buffer_with_attributes_create().

Referenced by add(), main(), replace_file_contents(), rz_io_zip_flush_file(), and zip_dir_add().

zip_source_buffer_create()

ZIP_EXTERN zip_source_t* zip_source_buffer_create	(	const void *	data,
		zip_uint64_t	len,
		int	freep,
		zip_error_t *	error
	)

Definition at line 97 of file zip_source_buffer.c.

                                                                                            {
    return zip_source_buffer_with_attributes_create(data, len, freep, NULL, error);
}

References error(), len, NULL, and zip_source_buffer_with_attributes_create().

Referenced by LLVMFuzzerTestOneInput(), main(), and read_to_memory().

zip_source_buffer_fragment()

ZIP_EXTERN zip_source_t* zip_source_buffer_fragment	(	zip_t *	za,
		const zip_buffer_fragment_t *	fragments,
		zip_uint64_t	nfragments,
		int	freep
	)

Definition at line 123 of file zip_source_buffer.c.

                                                                                                                  {
    if (za == NULL) {
        return NULL;
    }
 
    return zip_source_buffer_fragment_with_attributes_create(fragments, nfragments, freep, NULL, &za->error);
}

References zip::error, NULL, za, and zip_source_buffer_fragment_with_attributes_create().

zip_source_buffer_fragment_create()

ZIP_EXTERN zip_source_t* zip_source_buffer_fragment_create	(	const zip_buffer_fragment_t *	fragments,
		zip_uint64_t	nfragments,
		int	freep,
		zip_error_t *	error
	)

Definition at line 133 of file zip_source_buffer.c.

                                                                                                                                  {
    return zip_source_buffer_fragment_with_attributes_create(fragments, nfragments, freep, NULL, error);
}

References error(), NULL, and zip_source_buffer_fragment_with_attributes_create().

Referenced by read_to_memory().

zip_source_buffer_fragment_with_attributes_create()

zip_source_t * zip_source_buffer_fragment_with_attributes_create	(	const zip_buffer_fragment_t *	fragments,
		zip_uint64_t	nfragments,
		int	freep,
		zip_file_attributes_t *	attributes,
		zip_error_t *	error
	)

Definition at line 138 of file zip_source_buffer.c.

                                                                                                                                                                                     {
    struct read_data *ctx;
    zip_source_t *zs;
    buffer_t *buffer;
 
    if (fragments == NULL && nfragments > 0) {
        zip_error_set(error, ZIP_ER_INVAL, 0);
        return NULL;
    }
 
    if ((buffer = buffer_new(fragments, nfragments, freep, error)) == NULL) {
        return NULL;
    }
 
    if ((ctx = (struct read_data *)malloc(sizeof(*ctx))) == NULL) {
        zip_error_set(error, ZIP_ER_MEMORY, 0);
        buffer_free(buffer);
        return NULL;
    }
 
    ctx->in = buffer;
    ctx->out = NULL;
    ctx->mtime = time(NULL);
    if (attributes) {
        memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
    }
    else {
        zip_file_attributes_init(&ctx->attributes);
    }
    zip_error_init(&ctx->error);
 
    if ((zs = zip_source_function_create(read_data, ctx, error)) == NULL) {
        buffer_free(ctx->in);
        free(ctx);
        return NULL;
    }
 
    return zs;
}

References read_data::attributes, buffer_free(), buffer_new(), ctx::error, error(), free(), ctx::in, malloc(), memcpy(), NULL, ctx::out, time, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), zip_file_attributes_init(), and zip_source_function_create().

Referenced by zip_source_buffer_fragment(), zip_source_buffer_fragment_create(), and zip_source_buffer_with_attributes_create().

zip_source_buffer_with_attributes()

zip_source_t* zip_source_buffer_with_attributes	(	zip_t *	za,
		const void *	data,
		zip_uint64_t	len,
		int	freep,
		zip_file_attributes_t *	attributes
	)

Definition at line 180 of file zip_source_buffer.c.

                                                                                                                               {
    return zip_source_buffer_with_attributes_create(data, len, freep, attributes, &za->error);
}

References read_data::attributes, zip::error, len, za, and zip_source_buffer_with_attributes_create().

zip_source_buffer_with_attributes_create()

zip_source_t * zip_source_buffer_with_attributes_create	(	const void *	data,
		zip_uint64_t	len,
		int	freep,
		zip_file_attributes_t *	attributes,
		zip_error_t *	error
	)

Definition at line 103 of file zip_source_buffer.c.

                                                                                                                                               {
    zip_buffer_fragment_t fragment;
 
    if (data == NULL) {
        if (len > 0) {
            zip_error_set(error, ZIP_ER_INVAL, 0);
            return NULL;
        }
 
        return zip_source_buffer_fragment_with_attributes_create(NULL, 0, freep, attributes, error);
    }
 
    fragment.data = (zip_uint8_t *)data;
    fragment.length = len;
 
    return zip_source_buffer_fragment_with_attributes_create(&fragment, 1, freep, attributes, error);
}

References zip_buffer_fragment::data, error(), len, zip_buffer_fragment::length, NULL, ZIP_ER_INVAL, zip_error_set(), and zip_source_buffer_fragment_with_attributes_create().

Referenced by _zip_source_zip_new(), zip_source_buffer(), zip_source_buffer_create(), and zip_source_buffer_with_attributes().