in-memory.c File Reference

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <zip.h>

Go to the source code of this file.

Functions
static int	get_data (void **datap, size_t *sizep, const char *archive)
static int	modify_archive (zip_t *za)
static int	use_data (void *data, size_t size, const char *archive)
int	main (int argc, char *argv[])

Function Documentation

get_data()

static int get_data ( void **  datap, size_t *  sizep, const char *  archive  )

static

Definition at line 43 of file in-memory.c.

                                                           {
    /* example implementation that reads data from file */
    struct stat st;
    FILE *fp;
 
    if ((fp = fopen(archive, "rb")) == NULL) {
        if (errno != ENOENT) {
            fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
            return -1;
        }
 
        *datap = NULL;
        *sizep = 0;
 
        return 0;
    }
 
    if (fstat(fileno(fp), &st) < 0) {
        fprintf(stderr, "can't stat %s: %s\n", archive, strerror(errno));
        fclose(fp);
        return -1;
    }
 
    if ((*datap = malloc((size_t)st.st_size)) == NULL) {
        fprintf(stderr, "can't allocate buffer\n");
        fclose(fp);
        return -1;
    }
 
    if (fread(*datap, 1, (size_t)st.st_size, fp) < (size_t)st.st_size) {
        fprintf(stderr, "can't read %s: %s\n", archive, strerror(errno));
        free(*datap);
        fclose(fp);
        return -1;
    }
 
    fclose(fp);
 
    *sizep = (size_t)st.st_size;
    return 0;
}

References ENOENT, benchmark::FILE, free(), fstat, malloc(), and NULL.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 124 of file in-memory.c.

                             {
    const char *archive;
    zip_source_t *src;
    zip_t *za;
    zip_error_t error;
    void *data;
    size_t size;
 
    if (argc < 2) {
        fprintf(stderr, "usage: %s archive\n", argv[0]);
        return 1;
    }
    archive = argv[1];
 
    /* get buffer with zip archive inside */
    if (get_data(&data, &size, archive) < 0) {
        return 1;
    }
 
    zip_error_init(&error);
    /* create source from buffer */
    if ((src = zip_source_buffer_create(data, size, 1, &error)) == NULL) {
        fprintf(stderr, "can't create source: %s\n", zip_error_strerror(&error));
        free(data);
        zip_error_fini(&error);
        return 1;
    }
 
    /* open zip archive from source */
    if ((za = zip_open_from_source(src, 0, &error)) == NULL) {
        fprintf(stderr, "can't open zip from source: %s\n", zip_error_strerror(&error));
        zip_source_free(src);
        zip_error_fini(&error);
        return 1;
    }
    zip_error_fini(&error);
 
    /* we'll want to read the data back after zip_close */
    zip_source_keep(src);
 
    /* modify archive */
    modify_archive(za);
 
    /* close archive */
    if (zip_close(za) < 0) {
        fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
        return 1;
    }
 
 
    /* copy new archive to buffer */
 
    if (zip_source_is_deleted(src)) {
        /* new archive is empty, thus no data */
        data = NULL;
    }
    else {
        zip_stat_t zst;
 
        if (zip_source_stat(src, &zst) < 0) {
            fprintf(stderr, "can't stat source: %s\n", zip_error_strerror(zip_source_error(src)));
            return 1;
        }
 
        size = zst.size;
 
        if (zip_source_open(src) < 0) {
            fprintf(stderr, "can't open source: %s\n", zip_error_strerror(zip_source_error(src)));
            return 1;
        }
        if ((data = malloc(size)) == NULL) {
            fprintf(stderr, "malloc failed: %s\n", strerror(errno));
            zip_source_close(src);
            return 1;
        }
        if ((zip_uint64_t)zip_source_read(src, data, size) < size) {
            fprintf(stderr, "can't read data from source: %s\n", zip_error_strerror(zip_source_error(src)));
            zip_source_close(src);
            free(data);
            return 1;
        }
        zip_source_close(src);
    }
 
    /* we're done with src */
    zip_source_free(src);
 
    /* use new data */
    use_data(data, size, archive);
 
    free(data);
 
    return 0;
}

References argv, error(), free(), get_data(), malloc(), modify_archive(), NULL, zip_stat::size, src, use_data(), za, zip_close(), zip_error_fini(), zip_error_init(), zip_error_strerror(), zip_open_from_source(), zip_source_buffer_create(), zip_source_close(), zip_source_error(), zip_source_free(), zip_source_is_deleted(), zip_source_keep(), zip_source_open(), zip_source_read(), zip_source_stat(), and zip_strerror().

modify_archive()

static int modify_archive ( zip_t *  za )

static

Definition at line 86 of file in-memory.c.

                          {
    /* modify the archive */
    return 0;
}

Referenced by main().

use_data()

static int use_data ( void *  data, size_t  size, const char *  archive  )

static

Definition at line 93 of file in-memory.c.

                                                       {
    /* example implementation that writes data to file */
    FILE *fp;
 
    if (data == NULL) {
        if (remove(archive) < 0 && errno != ENOENT) {
            fprintf(stderr, "can't remove %s: %s\n", archive, strerror(errno));
            return -1;
        }
        return 0;
    }
 
    if ((fp = fopen(archive, "wb")) == NULL) {
        fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
        return -1;
    }
    if (fwrite(data, 1, size, fp) < size) {
        fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
        fclose(fp);
        return -1;
    }
    if (fclose(fp) < 0) {
        fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
        return -1;
    }
 
    return 0;
}

References ENOENT, benchmark::FILE, and NULL.

Referenced by main().