ziptool_regress.c File Reference

#include "zip.h"
#include <sys/stat.h>
#include "ziptool.c"

Go to the source code of this file.

Classes
struct	source_nul

Macros
#define	ZIP_MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	FOR_REGRESS
#define	OPTIONS_REGRESS   "F:Hm"
#define	USAGE_REGRESS   " [-Hm] [-F fragment-size]"
#define	GETOPT_REGRESS
#define	DISPATCH_REGRESS

Typedefs
typedef struct source_nul	source_nul_t

Enumerations
enum	source_type_t { SOURCE_TYPE_NONE , SOURCE_TYPE_IN_MEMORY , SOURCE_TYPE_HOLE }

Functions
static int	add_nul (char *argv[])
static int	cancel (char *argv[])
static int	is_seekable (char *argv[])
static int	seek (char *argv[])
static int	unchange_one (char *argv[])
static int	unchange_all (char *argv[])
static int	zin_close (char *argv[])
zip_t *	ziptool_open (const char *archive, int flags, zip_error_t *error, zip_uint64_t offset, zip_uint64_t len)
zip_source_t *	source_hole_create (const char *, int flags, zip_error_t *)
static zip_t *	read_to_memory (const char *archive, int flags, zip_error_t *error, zip_source_t **srcp)
static zip_source_t *	source_nul (zip_t *za, zip_uint64_t length)
static int	cancel_callback (zip_t *archive, void *ud)
static zip_t *	read_hole (const char *archive, int flags, zip_error_t *error)
static zip_int64_t	source_nul_cb (void *ud, void *data, zip_uint64_t length, zip_source_cmd_t command)
static int	write_memory_src_to_file (const char *archive, zip_source_t *src)
int	ziptool_post_close (const char *archive)

Variables
source_type_t	source_type = SOURCE_TYPE_NONE
zip_uint64_t	fragment_size = 0
zip_source_t *	memory_src = NULL

Macro Definition Documentation

DISPATCH_REGRESS

#define DISPATCH_REGRESS

Value:

    {"add_nul", 2, "name length", "add NUL bytes", add_nul}, \
    {"cancel", 1, "limit", "cancel writing archive when limit% have been written (calls print_progress)", cancel}, \
    {"is_seekable", 1, "index", "report if entry is seekable", is_seekable}, \
    {"seek", 2, "index offset", "seek in entry to offset", seek}, \
    {"unchange", 1, "index", "revert changes for entry", unchange_one}, \
    {"unchange_all", 0, "", "revert all changes", unchange_all}, \
    { "zin_close", 1, "index", "close input zip_source (for internal tests)", zin_close }

Definition at line 39 of file ziptool_regress.c.

FOR_REGRESS

#define FOR_REGRESS

Definition at line 7 of file ziptool_regress.c.

GETOPT_REGRESS

#define GETOPT_REGRESS

Value:

    case 'H':                                       \
        source_type = SOURCE_TYPE_HOLE;             \
        break;                                      \
    case 'm':                                       \
        source_type = SOURCE_TYPE_IN_MEMORY;        \
        break;                                      \
    case 'F':                                       \
        fragment_size = strtoull(optarg, NULL, 10); \
        break;

Definition at line 26 of file ziptool_regress.c.

OPTIONS_REGRESS

#define OPTIONS_REGRESS   "F:Hm"

Definition at line 22 of file ziptool_regress.c.

USAGE_REGRESS

#define USAGE_REGRESS   " [-Hm] [-F fragment-size]"

Definition at line 24 of file ziptool_regress.c.

ZIP_MIN

#define ZIP_MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 5 of file ziptool_regress.c.

Typedef Documentation

source_nul_t

typedef struct source_nul source_nul_t

Enumeration Type Documentation

source_type_t

enum source_type_t

Enumerator
SOURCE_TYPE_NONE
SOURCE_TYPE_IN_MEMORY
SOURCE_TYPE_HOLE

Definition at line 9 of file ziptool_regress.c.

{ SOURCE_TYPE_NONE, SOURCE_TYPE_IN_MEMORY, SOURCE_TYPE_HOLE } source_type_t;

Function Documentation

add_nul()

static int add_nul ( char *  argv[] )

static

Definition at line 66 of file ziptool_regress.c.

                      {
    zip_source_t *zs;
    zip_uint64_t length = strtoull(argv[1], NULL, 10);
 
    if ((zs = source_nul(za, length)) == NULL) {
        fprintf(stderr, "can't create zip_source for length: %s\n", zip_strerror(za));
        return -1;
    }
 
    if (zip_add(za, argv[0], zs) == -1) {
        zip_source_free(zs);
        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
        return -1;
    }
    return 0;
}

References argv, length, NULL, source_nul(), za, zip_add(), zip_source_free(), and zip_strerror().

cancel()

static int cancel ( char *  argv[] )

static

Definition at line 92 of file ziptool_regress.c.

                     {
    zip_int64_t percent;
    percent = strtoll(argv[0], NULL, 10);
    if (percent > 100 || percent < 0) {
        fprintf(stderr, "invalid percentage '%" PRId64 "' for cancel (valid: 0 <= x <= 100)\n", percent);
        return -1;
    }
    progress_userdata.limit = ((double)percent) / 100;
 
    zip_register_cancel_callback_with_state(za, cancel_callback, NULL, NULL);
 
    /* needs the percentage updates from print_progress */
    print_progress(argv);
    return 0;
}

References argv, cancel_callback(), progress_userdata_s::limit, NULL, PRId64, print_progress(), progress_userdata, za, and zip_register_cancel_callback_with_state().

Referenced by RZ_PACKED().

cancel_callback()

static int cancel_callback ( zip_t *  archive, void *  ud  )

static

Definition at line 84 of file ziptool_regress.c.

                                          {
    if (progress_userdata.percentage >= progress_userdata.limit) {
        return -1;
    }
    return 0;
}

References progress_userdata_s::limit, progress_userdata_s::percentage, and progress_userdata.

Referenced by cancel().

is_seekable()

static int is_seekable ( char *  argv[] )

static

Definition at line 109 of file ziptool_regress.c.

                          {
    zip_uint64_t idx;
    zip_file_t *zf;
 
    idx = strtoull(argv[0], NULL, 10);
    if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
        fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
        return -1;
    }
    switch (zip_file_is_seekable(zf)) {
    case -1:
    fprintf(stderr, "can't check if file %" PRIu64 " is seekable: %s\n", idx, zip_strerror(za));
    return -1;
    case 0:
    printf("%" PRIu64 ": NOT seekable\n", idx);
    break;
    case 1:
    printf("%" PRIu64 ": seekable\n", idx);
    break;
    }
    return 0;
}

References argv, setup::idx, NULL, printf(), PRIu64, za, zip_file_is_seekable(), zip_fopen_index(), and zip_strerror().

read_hole()

static zip_t* read_hole ( const char *  archive, int  flags, zip_error_t *  error  )

static

Definition at line 196 of file ziptool_regress.c.

                                                              {
    zip_source_t *src = NULL;
    zip_t *zs = NULL;
 
    if (strcmp(archive, "/dev/stdin") == 0) {
        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
        return NULL;
    }
 
    if ((src = source_hole_create(archive, flags, error)) == NULL || (zs = zip_open_from_source(src, flags, error)) == NULL) {
        zip_source_free(src);
    }
 
    return zs;
}

References error(), flags, NULL, source_hole_create(), src, ZIP_ER_OPNOTSUPP, zip_error_set(), zip_open_from_source(), and zip_source_free().

Referenced by ziptool_open().

read_to_memory()

static zip_t * read_to_memory ( const char *  archive, int  flags, zip_error_t *  error, zip_source_t **  srcp  )

static

Definition at line 214 of file ziptool_regress.c.

                                                                                        {
    zip_source_t *src;
    zip_t *zb;
    FILE *fp;
 
    if (strcmp(archive, "/dev/stdin") == 0) {
        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
        return NULL;
    }
 
    if ((fp = fopen(archive, "rb")) == NULL) {
        if (errno == ENOENT) {
            src = zip_source_buffer_create(NULL, 0, 0, error);
        }
        else {
            zip_error_set(error, ZIP_ER_OPEN, errno);
            return NULL;
        }
    }
    else {
        struct stat st;
 
        if (fstat(fileno(fp), &st) < 0) {
            fclose(fp);
            zip_error_set(error, ZIP_ER_OPEN, errno);
            return NULL;
        }
        if (fragment_size == 0) {
            char *buf;
            if ((buf = malloc((size_t)st.st_size)) == NULL) {
                fclose(fp);
                zip_error_set(error, ZIP_ER_MEMORY, 0);
                return NULL;
            }
            if (fread(buf, (size_t)st.st_size, 1, fp) < 1) {
                free(buf);
                fclose(fp);
                zip_error_set(error, ZIP_ER_READ, errno);
                return NULL;
            }
            src = zip_source_buffer_create(buf, (zip_uint64_t)st.st_size, 1, error);
            if (src == NULL) {
                free(buf);
            }
        }
        else {
            zip_uint64_t nfragments, i, left;
            zip_buffer_fragment_t *fragments;
 
            nfragments = ((size_t)st.st_size + fragment_size - 1) / fragment_size;
            if ((fragments = malloc(sizeof(fragments[0]) * nfragments)) == NULL) {
                fclose(fp);
                zip_error_set(error, ZIP_ER_MEMORY, 0);
                return NULL;
            }
            for (i = 0; i < nfragments; i++) {
                left = ZIP_MIN(fragment_size, (size_t)st.st_size - i * fragment_size);
                if ((fragments[i].data = malloc(left)) == NULL) {
#ifndef __clang_analyzer__
                    /* fragments is initialized up to i - 1*/
                    while (--i > 0) {
                        free(fragments[i].data);
                    }
#endif
                    free(fragments);
                    fclose(fp);
                    zip_error_set(error, ZIP_ER_MEMORY, 0);
                    return NULL;
                }
                fragments[i].length = left;
                if (fread(fragments[i].data, left, 1, fp) < 1) {
#ifndef __clang_analyzer__
                    /* fragments is initialized up to i - 1*/
                    while (--i > 0) {
                        free(fragments[i].data);
                    }
#endif
                    free(fragments);
                    fclose(fp);
                    zip_error_set(error, ZIP_ER_READ, errno);
                    return NULL;
                }
            }
            src = zip_source_buffer_fragment_create(fragments, nfragments, 1, error);
            if (src == NULL) {
                for (i = 0; i < nfragments; i++) {
                    free(fragments[i].data);
                }
                free(fragments);
                fclose(fp);
                return NULL;
            }
            free(fragments);
        }
        fclose(fp);
    }
    if (src == NULL) {
        return NULL;
    }
    zb = zip_open_from_source(src, flags, error);
    if (zb == NULL) {
        zip_source_free(src);
        return NULL;
    }
    zip_source_keep(src);
    *srcp = src;
    return zb;
}

References ENOENT, error(), benchmark::FILE, flags, fragment_size, free(), fstat, i, zip_buffer_fragment::length, malloc(), NULL, src, ZIP_ER_MEMORY, ZIP_ER_OPEN, ZIP_ER_OPNOTSUPP, ZIP_ER_READ, zip_error_set(), ZIP_MIN, zip_open_from_source(), zip_source_buffer_create(), zip_source_buffer_fragment_create(), zip_source_free(), and zip_source_keep().

Referenced by ziptool_open().

seek()

static int seek ( char *  argv[] )

static

Definition at line 133 of file ziptool_regress.c.

                   {
    zip_uint64_t idx;
    zip_file_t *zf;
    zip_int64_t offset;
 
    idx = strtoull(argv[0], NULL, 10);
    offset = strtoull(argv[1], NULL, 10);
    if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
        fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
        return -1;
    }
    if (zip_fseek(zf, offset, SEEK_SET) == -1) {
    fprintf(stderr, "can't seek in file %" PRIu64 ": %s\n", idx, zip_strerror(za));
    return -1;
    }
    return 0;
}

References argv, setup::idx, NULL, PRIu64, SEEK_SET, za, zip_fopen_index(), zip_fseek(), and zip_strerror().

Referenced by arch_xap_disasm(), find_next_diff(), find_prev_diff(), parse_dbi_stream(), rz_analysis_function_type_matching_handler(), rz_core_analysis_types_propagation(), rz_io_desc_read(), rz_main_rizin(), rz_range_percent(), rz_table_visual_list(), rz_type_format_data(), rz_type_format_data_internal(), rz_type_format_struct(), and var_functions_show().

source_hole_create()

zip_source_t* source_hole_create	(	const char *	fname,
		int	flags,
		zip_error_t *	error
	)

Definition at line 94 of file source_hole.c.

                                                                     {
    hole_t *ud = hole_new(fname, flags, error);
 
    if (ud == NULL) {
        return NULL;
    }
    return zip_source_function_create(source_hole_cb, ud, error);
}

Referenced by read_hole().

source_nul()

static zip_source_t * source_nul ( zip_t *  za, zip_uint64_t  length  )

static

Definition at line 386 of file ziptool_regress.c.

                                           {
    source_nul_t *ctx;
    zip_source_t *src;
 
    if ((ctx = (source_nul_t *)malloc(sizeof(*ctx))) == NULL) {
        zip_error_set(zip_get_error(zs), ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    zip_error_init(&ctx->error);
    ctx->length = length;
    ctx->offset = 0;
 
    if ((src = zip_source_function(zs, source_nul_cb, ctx)) == NULL) {
        free(ctx);
        return NULL;
    }
 
    return src;
}

References ctx::error, free(), length, malloc(), NULL, source_nul_cb(), src, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), zip_get_error(), and zip_source_function().

Referenced by add_nul().

source_nul_cb()

static zip_int64_t source_nul_cb ( void *  ud, void *  data, zip_uint64_t  length, zip_source_cmd_t  command  )

static

Definition at line 331 of file ziptool_regress.c.

                                                                                   {
    source_nul_t *ctx = (source_nul_t *)ud;
 
    switch (command) {
    case ZIP_SOURCE_CLOSE:
        return 0;
 
    case ZIP_SOURCE_ERROR:
        return zip_error_to_data(&ctx->error, data, length);
 
    case ZIP_SOURCE_FREE:
        free(ctx);
        return 0;
 
    case ZIP_SOURCE_OPEN:
        ctx->offset = 0;
        return 0;
 
    case ZIP_SOURCE_READ:
        if (length > ZIP_INT64_MAX) {
            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
            return -1;
        }
 
        if (length > ctx->length - ctx->offset) {
            length = ctx->length - ctx->offset;
        }
 
        memset(data, 0, length);
        ctx->offset += length;
        return (zip_int64_t)length;
 
    case ZIP_SOURCE_STAT: {
        zip_stat_t *st = ZIP_SOURCE_GET_ARGS(zip_stat_t, data, length, &ctx->error);
 
        if (st == NULL) {
            return -1;
        }
 
        st->valid |= ZIP_STAT_SIZE;
        st->size = ctx->length;
 
        return 0;
    }
 
    case ZIP_SOURCE_SUPPORTS:
        return zip_source_make_command_bitmap(ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_STAT, -1);
 
    default:
        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
        return -1;
    }
}

References command, ctx::error, free(), length, memset(), NULL, zip_stat::size, zip_stat::valid, ZIP_ER_INVAL, ZIP_ER_OPNOTSUPP, zip_error_set(), zip_error_to_data(), ZIP_INT64_MAX, ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_ARGS, zip_source_make_command_bitmap(), ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_STAT, ZIP_SOURCE_SUPPORTS, and ZIP_STAT_SIZE.

Referenced by source_nul().

unchange_all()

static int unchange_all ( char *  argv[] )

static

Definition at line 152 of file ziptool_regress.c.

                           {
    if (zip_unchange_all(za) < 0) {
        fprintf(stderr, "can't revert changes to archive: %s\n", zip_strerror(za));
        return -1;
    }
    return 0;
}

References za, zip_strerror(), and zip_unchange_all().

unchange_one()

static int unchange_one ( char *  argv[] )

static

Definition at line 162 of file ziptool_regress.c.

                           {
    zip_uint64_t idx;
 
    idx = strtoull(argv[0], NULL, 10);
 
    if (zip_unchange(za, idx) < 0) {
    fprintf(stderr, "can't revert changes for entry %" PRIu64 ": %s", idx, zip_strerror(za));
    return -1;
    }
 
    return 0;
}

References argv, setup::idx, NULL, PRIu64, za, zip_strerror(), and zip_unchange().

write_memory_src_to_file()

static int write_memory_src_to_file ( const char *  archive, zip_source_t *  src  )

static

Definition at line 409 of file ziptool_regress.c.

                                                                 {
    zip_stat_t zst;
    char *buf;
    FILE *fp;
 
    if (zip_source_stat(src, &zst) < 0) {
        fprintf(stderr, "zip_source_stat on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
        return -1;
    }
    if (zip_source_open(src) < 0) {
        if (zip_error_code_zip(zip_source_error(src)) == ZIP_ER_DELETED) {
            if (unlink(archive) < 0 && errno != ENOENT) {
                fprintf(stderr, "unlink failed: %s\n", strerror(errno));
                return -1;
            }
            return 0;
        }
        fprintf(stderr, "zip_source_open on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
        return -1;
    }
    if ((buf = malloc(zst.size)) == NULL) {
        fprintf(stderr, "malloc failed: %s\n", strerror(errno));
        zip_source_close(src);
        return -1;
    }
    if (zip_source_read(src, buf, zst.size) < (zip_int64_t)zst.size) {
        fprintf(stderr, "zip_source_read on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
        zip_source_close(src);
        free(buf);
        return -1;
    }
    zip_source_close(src);
    if ((fp = fopen(archive, "wb")) == NULL) {
        fprintf(stderr, "fopen failed: %s\n", strerror(errno));
        free(buf);
        return -1;
    }
    if (fwrite(buf, zst.size, 1, fp) < 1) {
        fprintf(stderr, "fwrite failed: %s\n", strerror(errno));
        free(buf);
        fclose(fp);
        return -1;
    }
    free(buf);
    if (fclose(fp) != 0) {
        fprintf(stderr, "fclose failed: %s\n", strerror(errno));
        return -1;
    }
    return 0;
}

References ENOENT, benchmark::FILE, free(), malloc(), NULL, zip_stat::size, src, unlink, ZIP_ER_DELETED, zip_error_code_zip(), zip_error_strerror(), zip_source_close(), zip_source_error(), zip_source_open(), zip_source_read(), and zip_source_stat().

Referenced by ziptool_post_close().

zin_close()

static int zin_close ( char *  argv[] )

static

Definition at line 176 of file ziptool_regress.c.

                        {
    zip_uint64_t idx;
 
    idx = strtoull(argv[0], NULL, 10);
    if (idx >= z_in_count) {
        fprintf(stderr, "invalid argument '%" PRIu64 "', only %u zip sources open\n", idx, z_in_count);
        return -1;
    }
    if (zip_close(z_in[idx]) < 0) {
        fprintf(stderr, "can't close source archive: %s\n", zip_strerror(z_in[idx]));
        return -1;
    }
    z_in[idx] = z_in[z_in_count];
    z_in_count--;
 
    return 0;
}

References argv, setup::idx, NULL, PRIu64, z_in, z_in_count, zip_close(), and zip_strerror().

ziptool_open()

zip_t * ziptool_open	(	const char *	archive,
		int	flags,
		zip_error_t *	error,
		zip_uint64_t	offset,
		zip_uint64_t	len
	)

Definition at line 462 of file ziptool_regress.c.

                                                                                                        {
    switch (source_type) {
    case SOURCE_TYPE_NONE:
        za = read_from_file(archive, flags, error, offset, len);
        break;
 
    case SOURCE_TYPE_IN_MEMORY:
        za = read_to_memory(archive, flags, error, &memory_src);
        break;
 
    case SOURCE_TYPE_HOLE:
        za = read_hole(archive, flags, error);
        break;
    }
 
    return za;
}

References error(), flags, len, memory_src, read_from_file(), read_hole(), read_to_memory(), source_type, SOURCE_TYPE_HOLE, SOURCE_TYPE_IN_MEMORY, SOURCE_TYPE_NONE, and za.

ziptool_post_close()

int ziptool_post_close

(

const char *

archive

)

Definition at line 482 of file ziptool_regress.c.

                                        {
    if (source_type == SOURCE_TYPE_IN_MEMORY) {
        if (write_memory_src_to_file(archive, memory_src) < 0) {
            return -1;
        }
        zip_source_free(memory_src);
    }
 
    return 0;
}

References memory_src, source_type, SOURCE_TYPE_IN_MEMORY, write_memory_src_to_file(), and zip_source_free().

Variable Documentation

fragment_size

zip_uint64_t fragment_size = 0

Definition at line 12 of file ziptool_regress.c.

Referenced by read_to_memory().

memory_src

zip_source_t* memory_src = NULL

Definition at line 57 of file ziptool_regress.c.

Referenced by ziptool_open(), and ziptool_post_close().

source_type

source_type_t source_type = SOURCE_TYPE_NONE

Definition at line 11 of file ziptool_regress.c.

Referenced by ziptool_open(), and ziptool_post_close().