gzip.c File Reference

#include "../libisofs.h"
#include "../filter.h"
#include "../fsource.h"
#include "../util.h"
#include "../stream.h"
#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

Include dependency graph for gzip.c:

Go to the source code of this file.

Data Structures
struct	GzipFilterRuntime
struct	GzipFilterStreamData

Functions
static int	gzip_stream_uncompress (IsoStream *stream, void *buf, size_t desired)
static int	gzip_stream_close_flag (IsoStream *stream, int flag)
static int	gzip_stream_close (IsoStream *stream)
static int	gzip_stream_open_flag (IsoStream *stream, int flag)
static int	gzip_stream_open (IsoStream *stream)
static int	gzip_stream_convert (IsoStream *stream, void *buf, size_t desired, int flag)
static int	gzip_stream_compress (IsoStream *stream, void *buf, size_t desired)
static off_t	gzip_stream_get_size (IsoStream *stream)
static int	gzip_stream_is_repeatable (IsoStream *stream)
static void	gzip_stream_get_id (IsoStream *stream, unsigned int *fs_id, dev_t *dev_id, ino_t *ino_id)
static void	gzip_stream_free (IsoStream *stream)
static int	gzip_update_size (IsoStream *stream)
static IsoStream *	gzip_get_input_stream (IsoStream *stream, int flag)
static int	gzip_clone_stream (IsoStream *old_stream, IsoStream **new_stream, int flag)
static int	gzip_cmp_ino (IsoStream *s1, IsoStream *s2)
static int	gzip_uncompress_cmp_ino (IsoStream *s1, IsoStream *s2)
int	gzip_add_filter (IsoFile *file, int flag)
int	iso_file_add_gzip_filter (IsoFile *file, int flag)
	Install a gzip or gunzip filter on top of the content stream of a data file. More...
int	iso_gzip_get_refcounts (off_t *gzip_count, off_t *gunzip_count, int flag)
	Inquire the number of gzip compression and uncompression filters which are in use. More...

Variables
static off_t	gzip_ref_count = 0
static off_t	gunzip_ref_count = 0
IsoStreamIface	gzip_stream_compress_class
IsoStreamIface	gzip_stream_uncompress_class

Function Documentation

gzip_add_filter()

int gzip_add_filter	(	IsoFile *	file,
		int	flag
	)

Definition at line 764 of file gzip.c.

{
 
#ifdef Libisofs_with_zliB
 
    int ret;
    FilterContext *f = NULL;
    IsoStream *stream;
    off_t original_size = 0, filtered_size = 0;
 
    if (flag & 4)
        return 2;
 
    original_size = iso_file_get_size(file);
 
    ret = gzip_create_context(&f, flag & 2);
    if (ret < 0) {
        return ret;
    }
    ret = iso_file_add_filter(file, f, 0);
    free(f);
    if (ret < 0) {
        return ret;
    }
    if (flag & 8) /* size will be filled in by caller */
        return ISO_SUCCESS;
 
    /* Run a full filter process getsize so that the size is cached */
    stream = iso_file_get_stream(file);
    filtered_size = iso_stream_get_size(stream);
    if (filtered_size < 0) {
        iso_file_remove_filter(file, 0);
        return filtered_size;
    }
    if ((filtered_size >= original_size ||
        ((flag & 1) && filtered_size / 2048 >= original_size / 2048))
        && !(flag & 2)){
        ret = iso_file_remove_filter(file, 0);
        if (ret < 0) {
            return ret;
        }
        return 2;
    }
    return ISO_SUCCESS;
 
#else
 
    return ISO_ZLIB_NOT_ENABLED;
 
#endif /* ! Libisofs_with_zliB */
 
}

References iso_file_add_filter(), iso_file_get_size(), iso_file_get_stream(), iso_file_remove_filter(), iso_stream_get_size(), ISO_SUCCESS, and ISO_ZLIB_NOT_ENABLED.

Referenced by iso_file_add_gzip_filter().

gzip_clone_stream()

static int gzip_clone_stream ( IsoStream *  old_stream, IsoStream **  new_stream, int  flag  )

static

Definition at line 535 of file gzip.c.

{
 
#ifdef Libisofs_with_zliB
 
    int ret;
    IsoStream *new_input_stream, *stream;
    GzipFilterStreamData *stream_data, *old_stream_data;
 
    if (flag)
        return ISO_STREAM_NO_CLONE; /* unknown option required */
 
    stream_data = calloc(1, sizeof(GzipFilterStreamData));
    if (stream_data == NULL)
        return ISO_OUT_OF_MEM;
    ret = iso_stream_clone_filter_common(old_stream, &stream,
                                         &new_input_stream, 0);
    if (ret < 0) {
        free((char *) stream_data);
        return ret;
    }
    old_stream_data = (GzipFilterStreamData *) old_stream->data;
    stream_data->orig = new_input_stream;
    stream_data->size = old_stream_data->size;
    stream_data->running = NULL;
    stream_data->id = ++gzip_ino_id;
    stream->data = stream_data;
    *new_stream = stream;
    return ISO_SUCCESS;
 
#else /* Libisofs_with_zliB */
 
    return ISO_STREAM_NO_CLONE;
 
#endif /* ! Libisofs_with_zliB */
 
}

References iso_stream::data, GzipFilterStreamData::id, ISO_OUT_OF_MEM, iso_stream_clone_filter_common(), ISO_STREAM_NO_CLONE, ISO_SUCCESS, GzipFilterStreamData::orig, GzipFilterStreamData::running, and GzipFilterStreamData::size.

gzip_cmp_ino()

static int gzip_cmp_ino ( IsoStream *  s1, IsoStream *  s2  )

static

Definition at line 615 of file gzip.c.

{
    /* This function may rely on being called by iso_stream_cmp_ino()
       only with s1, s2 which both point to it as their .cmp_ino() function.
       It would be a programming error to let any other than 
       gzip_stream_compress_class point to gzip_cmp_ino().
       This fallback endangers transitivity of iso_stream_cmp_ino().
    */
    if (s1->class != s2->class || (s1->class != &gzip_stream_compress_class &&
                                   s2->class != &gzip_stream_compress_class))
        return iso_stream_cmp_ino(s1, s2, 1);
 
    /* Both streams apply the same treatment to their input streams */
    return iso_stream_cmp_ino(iso_stream_get_input_stream(s1, 0),
                              iso_stream_get_input_stream(s2, 0), 0);
}   

References iso_stream::class, gzip_stream_compress_class, iso_stream_cmp_ino(), and iso_stream_get_input_stream().

gzip_get_input_stream()

static IsoStream* gzip_get_input_stream ( IsoStream *  stream, int  flag  )

static

Definition at line 522 of file gzip.c.

{
    GzipFilterStreamData *data;
 
    if (stream == NULL) {
        return NULL;
    }
    data = stream->data;
    return data->orig;
}

References iso_stream::data, and GzipFilterStreamData::orig.

gzip_stream_close()

static int gzip_stream_close ( IsoStream *  stream )

static

Definition at line 231 of file gzip.c.

{
    return gzip_stream_close_flag(stream, 0);
}

References gzip_stream_close_flag().

Referenced by gzip_stream_free(), and gzip_stream_get_size().

gzip_stream_close_flag()

static int gzip_stream_close_flag ( IsoStream *  stream, int  flag  )

static

Definition at line 195 of file gzip.c.

{
 
#ifdef Libisofs_with_zliB
 
    GzipFilterStreamData *data;
 
    if (stream == NULL) {
        return ISO_NULL_POINTER;
    }
    data = stream->data;
 
    if (data->running == NULL) {
        return 1;
    }
    if (stream->class->read == &gzip_stream_uncompress) {
        inflateEnd(&(data->running->strm));
    } else {
        deflateEnd(&(data->running->strm));
    }
    gzip_running_destroy(&(data->running), 0);
 
    if (flag & 1)
        return 1;
    return iso_stream_close(data->orig);
 
#else
 
    return ISO_ZLIB_NOT_ENABLED;
 
#endif
 
}

References iso_stream::class, iso_stream::data, gzip_stream_uncompress(), ISO_NULL_POINTER, iso_stream_close(), ISO_ZLIB_NOT_ENABLED, GzipFilterStreamData::orig, IsoStream_Iface::read, and GzipFilterStreamData::running.

Referenced by gzip_stream_close().

gzip_stream_compress()

static int gzip_stream_compress ( IsoStream *  stream, void *  buf, size_t  desired  )

static

Definition at line 416 of file gzip.c.

{
    return gzip_stream_convert(stream, buf, desired, 0);
}

References gzip_stream_convert().

gzip_stream_convert()

static int gzip_stream_convert ( IsoStream *  stream, void *  buf, size_t  desired, int  flag  )

static

Definition at line 316 of file gzip.c.

{
 
#ifdef Libisofs_with_zliB
 
    int ret, todo, cnv_ret, c_bytes;
    GzipFilterStreamData *data;
    GzipFilterRuntime *rng;
    size_t fill = 0;
    z_stream *strm;
 
    if (stream == NULL) {
        return ISO_NULL_POINTER;
    }
    data = stream->data;
    rng= data->running;
    if (rng == NULL) {
        return ISO_FILE_NOT_OPENED;
    }
    strm = &(rng->strm);
    if (rng->error_ret < 0) {
        return rng->error_ret;
    } else if (rng->error_ret == 0) {
        if (rng->out_buffer_size - strm->avail_out
            - (rng->rpt - rng->out_buffer) <= 0)
            return 0;
    }
 
    while (1) {
 
        /* Transfer eventual converted bytes from strm to buf */
        c_bytes = rng->out_buffer_size - strm->avail_out
                  - (rng->rpt - rng->out_buffer);
        if (c_bytes > 0) {
           todo = desired - fill;
           if (todo > c_bytes)
               todo = c_bytes;
           memcpy(((char *) buf) + fill, rng->rpt, todo);
           rng->rpt += todo;
           fill += todo;
           rng->out_counter += todo;
        }
 
        if (fill >= desired || rng->error_ret == 0)
           return fill;
 
        /* All buffered out data are consumed now */
        rng->rpt = rng->out_buffer;
        strm->next_out = (Bytef *) rng->out_buffer;
        strm->avail_out = rng->out_buffer_size;
 
        if (strm->avail_in == 0) {
            /* All pending input is consumed. Get new input. */
            ret = iso_stream_read(data->orig, rng->in_buffer,
                                  rng->in_buffer_size);
            if (ret < 0)
                return (rng->error_ret = ret);
            if (ret == 0) {
                if (flag & 2) {
                    /* Early input EOF */
                    return (rng->error_ret = ISO_ZLIB_EARLY_EOF);
                } else {
                    /* Tell zlib by the next call that it is over */
                    rng->do_flush = Z_FINISH;
                }
            }
            strm->next_in = (Bytef *) rng->in_buffer;
            strm->avail_in = ret;
            rng->in_counter += ret;
        }
 
        /* Submit input and fetch output until input is consumed */
        while (1) {
            if (flag & 2) {
                cnv_ret = inflate(strm, rng->do_flush);
            } else {
                cnv_ret = deflate(strm, rng->do_flush);
            }
            if (cnv_ret == Z_STREAM_ERROR || cnv_ret == Z_BUF_ERROR) {
                return (rng->error_ret = ISO_ZLIB_COMPR_ERR);
            }
            if ((int) strm->avail_out < rng->out_buffer_size)
        break; /* output is available */
            if (strm->avail_in == 0) /* all pending input consumed */
        break;
        }
        if (cnv_ret == Z_STREAM_END)
            rng->error_ret = 0;
    }
    return fill;
 
#else
 
    return ISO_ZLIB_NOT_ENABLED;
 
#endif
 
}

References iso_stream::data, GzipFilterRuntime::do_flush, GzipFilterRuntime::error_ret, GzipFilterRuntime::in_buffer, GzipFilterRuntime::in_buffer_size, GzipFilterRuntime::in_counter, ISO_FILE_NOT_OPENED, ISO_NULL_POINTER, iso_stream_read(), ISO_ZLIB_COMPR_ERR, ISO_ZLIB_EARLY_EOF, ISO_ZLIB_NOT_ENABLED, GzipFilterStreamData::orig, GzipFilterRuntime::out_buffer, GzipFilterRuntime::out_buffer_size, GzipFilterRuntime::out_counter, GzipFilterRuntime::rpt, and GzipFilterStreamData::running.

Referenced by gzip_stream_compress(), and gzip_stream_uncompress().

gzip_stream_free()

static void gzip_stream_free ( IsoStream *  stream )

static

Definition at line 490 of file gzip.c.

{
    GzipFilterStreamData *data;
 
    if (stream == NULL) {
        return;
    }
    data = stream->data;
    if (data->running != NULL) {
        gzip_stream_close(stream);
    }
    if (stream->class->read == &gzip_stream_uncompress) {
        if (--gunzip_ref_count < 0)
            gunzip_ref_count = 0;
    } else {
        if (--gzip_ref_count < 0)
            gzip_ref_count = 0;
    }
    iso_stream_unref(data->orig);
    free(data);
}

References iso_stream::class, iso_stream::data, gunzip_ref_count, gzip_ref_count, gzip_stream_close(), gzip_stream_uncompress(), iso_stream_unref(), GzipFilterStreamData::orig, IsoStream_Iface::read, and GzipFilterStreamData::running.

gzip_stream_get_id()

static void gzip_stream_get_id ( IsoStream *  stream, unsigned int *  fs_id, dev_t *  dev_id, ino_t *  ino_id  )

static

Definition at line 477 of file gzip.c.

{
    GzipFilterStreamData *data;
 
    data = stream->data;
    *fs_id = ISO_FILTER_FS_ID;
    *dev_id = ISO_FILTER_GZIP_DEV_ID;
    *ino_id = data->id;
}

References iso_stream::data, GzipFilterStreamData::id, ISO_FILTER_FS_ID, and ISO_FILTER_GZIP_DEV_ID.

gzip_stream_get_size()

static off_t gzip_stream_get_size ( IsoStream *  stream )

static

Definition at line 429 of file gzip.c.

{
    int ret, ret_close;
    off_t count = 0;
    GzipFilterStreamData *data;
    char buf[64 * 1024];
    size_t bufsize = 64 * 1024;
 
    if (stream == NULL) {
        return ISO_NULL_POINTER;
    }
    data = stream->data;
 
    if (data->size >= 0) {
        return data->size;
    }
 
    /* Run filter command and count output bytes */
    ret = gzip_stream_open_flag(stream, 1);
    if (ret < 0) {
        return ret;
    }
    while (1) {
        ret = stream->class->read(stream, buf, bufsize);
        if (ret <= 0)
    break;
        count += ret;
    }
    ret_close = gzip_stream_close(stream);
    if (ret < 0)
        return ret;
    if (ret_close < 0)
        return ret_close;
 
    data->size = count;
    return count;
}

References iso_stream::class, iso_stream::data, gzip_stream_close(), gzip_stream_open_flag(), ISO_NULL_POINTER, IsoStream_Iface::read, and GzipFilterStreamData::size.

gzip_stream_is_repeatable()

static int gzip_stream_is_repeatable ( IsoStream *  stream )

static

Definition at line 469 of file gzip.c.

{
    /* Only repeatable streams are accepted as orig */
    return 1;
}

gzip_stream_open()

static int gzip_stream_open ( IsoStream *  stream )

static

Definition at line 306 of file gzip.c.

{
    return gzip_stream_open_flag(stream, 0);
}

References gzip_stream_open_flag().

gzip_stream_open_flag()

static int gzip_stream_open_flag ( IsoStream *  stream, int  flag  )

static

Definition at line 241 of file gzip.c.

{
 
#ifdef Libisofs_with_zliB
 
    GzipFilterStreamData *data;
    GzipFilterRuntime *running = NULL;
    int ret;
    z_stream *strm;
 
    if (stream == NULL) {
        return ISO_NULL_POINTER;
    }
    data = (GzipFilterStreamData*) stream->data;
    if (data->running != NULL) {
        return ISO_FILE_ALREADY_OPENED;
    }
    if (data->size < 0 && !(flag & 1)) {
        /* Do the size determination run now, so that the size gets cached
           and .get_size() will not fail on an opened stream.
        */
        stream->class->get_size(stream);
    }
 
    ret = gzip_running_new(&running,
                           stream->class->read == &gzip_stream_uncompress);
    if (ret < 0) {
        return ret;
    }
    data->running = running;
 
    /* Start up zlib compression context */
    strm = &(running->strm);
    strm->zalloc = Z_NULL;
    strm->zfree = Z_NULL;
    strm->opaque = Z_NULL;
    if (stream->class->read == &gzip_stream_uncompress) {
        ret = inflateInit2(strm, 15 | 16);
    } else {
        ret = deflateInit2(strm, gzip_compression_level, Z_DEFLATED,
                           15 | 16, 8, Z_DEFAULT_STRATEGY);
    }
    if (ret != Z_OK)
        return ISO_ZLIB_COMPR_ERR;
    strm->next_out = (Bytef *) running->out_buffer;
    strm->avail_out = running->out_buffer_size;
 
    /* Open input stream */
    ret = iso_stream_open(data->orig);
    if (ret < 0) {
        return ret;
    }
 
    return 1;
 
#else
 
    return ISO_ZLIB_NOT_ENABLED;
 
#endif
 
}

References iso_stream::class, iso_stream::data, IsoStream_Iface::get_size, gzip_stream_uncompress(), ISO_FILE_ALREADY_OPENED, ISO_NULL_POINTER, iso_stream_open(), ISO_ZLIB_COMPR_ERR, ISO_ZLIB_NOT_ENABLED, GzipFilterStreamData::orig, GzipFilterRuntime::out_buffer, GzipFilterRuntime::out_buffer_size, IsoStream_Iface::read, GzipFilterStreamData::running, and GzipFilterStreamData::size.

Referenced by gzip_stream_get_size(), and gzip_stream_open().

gzip_stream_uncompress()

static int gzip_stream_uncompress ( IsoStream *  stream, void *  buf, size_t  desired  )

static

Definition at line 422 of file gzip.c.

{
    return gzip_stream_convert(stream, buf, desired, 2);
}

References gzip_stream_convert().

Referenced by gzip_stream_close_flag(), gzip_stream_free(), and gzip_stream_open_flag().

gzip_uncompress_cmp_ino()

static int gzip_uncompress_cmp_ino ( IsoStream *  s1, IsoStream *  s2  )

static

Definition at line 634 of file gzip.c.

{
    /* This function may rely on being called by iso_stream_cmp_ino()
       only with s1, s2 which both point to it as their .cmp_ino() function.
       It would be a programming error to let any other than 
       gzip_stream_uncompress_class point to gzip_uncompress_cmp_ino().
    */
    if (s1->class != s2->class ||
        (s1->class != &gzip_stream_uncompress_class &&
         s2->class != &gzip_stream_uncompress_class))
        return iso_stream_cmp_ino(s1, s2, 1);
 
    /* Both streams apply the same treatment to their input streams */
    return iso_stream_cmp_ino(iso_stream_get_input_stream(s1, 0),
                              iso_stream_get_input_stream(s2, 0), 0);
}   

References iso_stream::class, gzip_stream_uncompress_class, iso_stream_cmp_ino(), and iso_stream_get_input_stream().

gzip_update_size()

static int gzip_update_size ( IsoStream *  stream )

static

Definition at line 514 of file gzip.c.

{
    /* By principle size is determined only once */
    return 1;
}

iso_file_add_gzip_filter()

int iso_file_add_gzip_filter	(	IsoFile *	file,
		int	flag
	)

Install a gzip or gunzip filter on top of the content stream of a data file.

gzip is a compression format which is used by programs gzip and gunzip. The filter will not be installed if its output size is not smaller than the size of the input stream. This is only enabled if the use of libz was enabled at compile time.

Parameters

file	The data file node which shall show filtered content.
flag	Bitfield for control purposes bit0= Do not install filter if the number of output blocks is not smaller than the number of input blocks. Block size is 2048. bit1= Install a decompression filter rather than one for compression. bit2= Only inquire availability of gzip filtering. file may be NULL. If available return 2, else return error. bit3= is reserved for internal use and will be forced to 0

Returns

1 on success, 2 if filter available but installation revoked <0 on error, e.g. ISO_ZLIB_NOT_ENABLED

Since

0.6.18

Definition at line 819 of file gzip.c.

{
    return gzip_add_filter(file, flag & ~8);
}

References gzip_add_filter().

iso_gzip_get_refcounts()

int iso_gzip_get_refcounts	(	off_t *	gzip_count,
		off_t *	gunzip_count,
		int	flag
	)

Inquire the number of gzip compression and uncompression filters which are in use.

Parameters

gzip_count	Will return the number of currently installed compression filters.
gunzip_count	Will return the number of currently installed uncompression filters.
flag	Bitfield for control purposes, unused yet, submit 0

Returns

1 on success, <0 on error

Since

0.6.18

Definition at line 826 of file gzip.c.

{
    *gzip_count = gzip_ref_count;
    *gunzip_count = gunzip_ref_count;
    return ISO_SUCCESS;
}

References gunzip_ref_count, gzip_ref_count, and ISO_SUCCESS.

Variable Documentation

gunzip_ref_count

off_t gunzip_ref_count = 0

static

Definition at line 139 of file gzip.c.

Referenced by gzip_stream_free(), and iso_gzip_get_refcounts().

gzip_ref_count

off_t gzip_ref_count = 0

static

Definition at line 136 of file gzip.c.

Referenced by gzip_stream_free(), and iso_gzip_get_refcounts().

gzip_stream_compress_class

IsoStreamIface gzip_stream_compress_class

Initial value:

= {
    4,
    "gzip",
    gzip_stream_open,
    gzip_stream_close,
    gzip_stream_get_size,
    gzip_stream_compress,
    gzip_stream_is_repeatable,
    gzip_stream_get_id,
    gzip_stream_free,
    gzip_update_size,
    gzip_get_input_stream,
    gzip_cmp_ino,
    gzip_clone_stream
}

Definition at line 580 of file gzip.c.

Referenced by gzip_cmp_ino().

gzip_stream_uncompress_class

IsoStreamIface gzip_stream_uncompress_class

Initial value:

= {
    4,
    "pizg",
    gzip_stream_open,
    gzip_stream_close,
    gzip_stream_get_size,
    gzip_stream_uncompress,
    gzip_stream_is_repeatable,
    gzip_stream_get_id,
    gzip_stream_free,
    gzip_update_size,
    gzip_get_input_stream,
    gzip_uncompress_cmp_ino,
    gzip_clone_stream
}

Definition at line 597 of file gzip.c.

Referenced by gzip_uncompress_cmp_ino().