hole.c File Reference

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include "getopt.h"
#include "zip.h"

Go to the source code of this file.

Functions
zip_source_t *	source_hole_create (const char *, int flags, zip_error_t *)
static int	copy_source (zip_source_t *from, zip_source_t *to)
static zip_source_t *	open_compressed (const char *fname, int flags)
static zip_source_t *	open_file (const char *fname)
static void	usage (void)
int	main (int argc, char **argv)

Variables
const char *	progname

Function Documentation

copy_source()

static int copy_source ( zip_source_t *  from, zip_source_t *  to  )

static

Definition at line 53 of file hole.c.

                                                  {
    zip_uint8_t buf[8192];
    zip_int64_t n;
 
    if (zip_source_open(from) < 0) {
        fprintf(stderr, "%s: can't open source for reading: %s\n", progname, zip_error_strerror(zip_source_error(from)));
        return -1;
    }
 
    if (zip_source_begin_write(to) < 0) {
        fprintf(stderr, "%s: can't open source for writing: %s\n", progname, zip_error_strerror(zip_source_error(to)));
        zip_source_close(from);
        return -1;
    }
 
    while ((n = zip_source_read(from, buf, sizeof(buf))) > 0) {
        if (zip_source_write(to, buf, (zip_uint64_t)n) != n) {
            fprintf(stderr, "%s: can't write to source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
            zip_source_close(from);
            zip_source_rollback_write(to);
            return -1;
        }
    }
 
    if (n < 0) {
        fprintf(stderr, "%s: can't read from source: %s\n", progname, zip_error_strerror(zip_source_error(from)));
        zip_source_close(from);
        zip_source_rollback_write(to);
        return -1;
    }
 
    zip_source_close(from);
 
    if (zip_source_commit_write(to) < 0) {
        fprintf(stderr, "%s: can't commit source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
        zip_source_rollback_write(to);
        return -1;
    }
 
    return 0;
}

References from, n, progname, to, zip_error_strerror(), zip_source_begin_write(), zip_source_close(), zip_source_commit_write(), zip_source_error(), zip_source_open(), zip_source_read(), zip_source_rollback_write(), and zip_source_write().

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 139 of file hole.c.

                            {
    zip_source_t *from;
    zip_source_t *to;
    int c, err;
    int compress = 1;
    int decompress = 0;
 
    progname = argv[0];
 
    while ((c = getopt(argc, argv, "du")) != -1) {
        switch (c) {
        case 'd':
            compress = 0;
            decompress = 1;
            break;
 
        case 'u':
            compress = 1;
            decompress = 1;
            break;
 
        default:
            usage();
            break;
        }
    }
 
    if (optind + 2 != argc) {
        usage();
    }
 
    if (decompress) {
        from = open_compressed(argv[optind], 0);
    }
    else {
        from = open_file(argv[optind]);
    }
 
    if (compress) {
        to = open_compressed(argv[optind + 1], ZIP_CREATE);
    }
    else {
        to = open_file(argv[optind + 1]);
    }
 
    err = copy_source(from, to);
 
    zip_source_free(from);
    zip_source_free(to);
 
    exit(err < 0 ? 1 : 0);
}

References argv, c, compress(), copy_source(), decompress(), err, test-lz4-list::exit, from, getopt(), open_compressed(), open_file(), optind, progname, to, usage(), ZIP_CREATE, and zip_source_free().

open_compressed()

static zip_source_t* open_compressed ( const char *  fname, int  flags  )

static

Definition at line 97 of file hole.c.

                                              {
    zip_error_t error;
    zip_source_t *src;
 
    zip_error_init(&error);
 
    if ((src = source_hole_create(fname, flags, &error)) == NULL) {
        fprintf(stderr, "%s: can't open compressed file %s: %s\n", progname, fname, zip_error_strerror(&error));
        zip_error_fini(&error);
        exit(1);
    }
 
    return src;
}

References error(), test-lz4-list::exit, flags, create_tags_rz::fname, NULL, progname, source_hole_create(), src, zip_error_fini(), zip_error_init(), and zip_error_strerror().

Referenced by main().

open_file()

static zip_source_t* open_file ( const char *  fname )

static

Definition at line 114 of file hole.c.

                             {
    zip_error_t error;
    zip_source_t *src;
 
    zip_error_init(&error);
 
    if ((src = zip_source_file_create(fname, 0, 0, &error)) == NULL) {
        fprintf(stderr, "%s: can't open file %s: %s\n", progname, fname, zip_error_strerror(&error));
        zip_error_fini(&error);
        exit(1);
    }
 
    return src;
}

References error(), test-lz4-list::exit, create_tags_rz::fname, NULL, progname, src, zip_error_fini(), zip_error_init(), zip_error_strerror(), and zip_source_file_create().

Referenced by main().

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);
}

References error(), flags, create_tags_rz::fname, hole_new(), NULL, source_hole_cb(), and zip_source_function_create().

Referenced by open_compressed().

usage()

static void usage ( void  )

static

Definition at line 131 of file hole.c.

            {
    fprintf(stderr, "usage: %s [-du] in out\n", progname);
    fprintf(stderr, "\nOptions:\n  -d  decompress in\n  -u  update in\n");
    exit(1);
}

References test-lz4-list::exit, and progname.

Referenced by main().

Variable Documentation

progname

const char* progname

Definition at line 49 of file hole.c.

Referenced by copy_source(), main(), open_compressed(), open_file(), and usage().