/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* gsf-output-gzip.c: wrapper to compress to gzipped output. See rfc1952.
*
* Copyright (C) 2002-2006 Jon K Hellan (hellan@acm.org)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2.1 of the GNU Lesser General Public
* License as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
* USA
*/
#include <gsf-config.h>
#include <gsf/gsf-output-gzip.h>
#include <gsf/gsf-output-impl.h>
#include <gsf/gsf-impl-utils.h>
#include <gsf/gsf-utils.h>
#include <zlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
static GObjectClass *parent_class;
struct _GsfOutputGZip {
GsfOutput output;
GsfOutput *sink; /* compressed data */
gboolean raw; /* No header and no trailer. */
z_stream stream;
uLong crc; /* crc32 of uncompressed data */
size_t isize;
guint8 *buf;
size_t buf_size;
};
typedef struct {
GsfOutputClass output_class;
} GsfOutputGZipClass;
enum {
PROP_0,
PROP_RAW,
PROP_SINK
};
/* gzip flag byte */
#define GZIP_ORIGINAL_NAME 0x08 /* the original is stored */
static gboolean
init_gzip (GsfOutputGZip *gzip)
{
int ret;
ret = deflateInit2 (&gzip->stream, Z_DEFAULT_COMPRESSION,
Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL,
Z_DEFAULT_STRATEGY);
if (ret != Z_OK)
return FALSE;
if (!gzip->buf) {
gzip->buf_size = 0x100;
gzip->buf = g_new (guint8, gzip->buf_size);
}
gzip->stream.next_out = gzip->buf;
gzip->stream.avail_out = gzip->buf_size;
return TRUE;
}
static gboolean
gzip_output_header (GsfOutputGZip *gzip)
{
guint8 buf[3 + 1 + 4 + 2];
static guint8 const gzip_signature[] = { 0x1f, 0x8b, 0x08 } ;
time_t mtime = time (NULL);
char const *name = gsf_output_name (gzip->sink);
/* FIXME: What to do about gz extension ... ? */
int nlen = 0; /* name ? strlen (name) : 0; */
gboolean ret;
memset (buf, 0, sizeof buf);
memcpy (buf, gzip_signature, 3);
if (nlen > 0)
buf[3] = GZIP_ORIGINAL_NAME;
GSF_LE_SET_GUINT32 (buf + 4, (guint32) mtime);
buf[9] = 3; /* UNIX */
ret = gsf_output_write (gzip->sink, sizeof buf, buf);
if (ret && name && nlen > 0)
ret = gsf_output_write (gzip->sink, nlen, name);
return ret;
}
/**
* gsf_output_gzip_new :
* @sink : The underlying data source.
* @err : optionally %NULL.
*
* Adds a reference to @sink.
*
* Returns: a new file or %NULL.
**/
GsfOutput *
gsf_output_gzip_new (GsfOutput *sink, GError **err)
{
GsfOutput *output;
GError const *con_err;
g_return_val_if_fail (GSF_IS_OUTPUT (sink), NULL);
output = g_object_new (GSF_OUTPUT_GZIP_TYPE, "sink", sink, NULL);
if (G_UNLIKELY (NULL == output)) return NULL;
con_err = gsf_output_error (output);
if (con_err) {
if (err)
*err = g_error_copy (con_err);
g_object_unref (output);
return NULL;
}
return output;
}
static void
gsf_output_gzip_finalize (GObject *obj)
{
GsfOutputGZip *gzip = (GsfOutputGZip *)obj;
if (gzip->sink != NULL) {
g_object_unref (G_OBJECT (gzip->sink));
gzip->sink = NULL;
}
g_free (gzip->buf);
/* FIXME: check for error? */
deflateEnd (&gzip->stream);
parent_class->finalize (obj);
}
static gboolean
gzip_output_block (GsfOutputGZip *gzip)
{
size_t num_bytes = gzip->buf_size - gzip->stream.avail_out;
if (!gsf_output_write (gzip->sink, num_bytes, gzip->buf)) {
gsf_output_set_error (GSF_OUTPUT (gzip), 0,
"Failed to write");
return FALSE;
}
gzip->stream.next_out = gzip->buf;
gzip->stream.avail_out = gzip->buf_size;
return TRUE;
}
static gboolean
gzip_flush (GsfOutputGZip *gzip)
{
int zret;
do {
zret = deflate (&gzip->stream, Z_FINISH);
if (zret == Z_OK) {
/* In this case Z_OK means more buffer space
needed */
if (!gzip_output_block (gzip))
return FALSE;
}
} while (zret == Z_OK);
if (zret != Z_STREAM_END) {
gsf_output_set_error (GSF_OUTPUT (gzip), 0,
"Unexpected compression failure");
g_warning ("Unexpected error code %d from zlib during compression.",
zret);
return FALSE;
}
if (!gzip_output_block (gzip))
return FALSE;
return TRUE;
}
static gboolean
gsf_output_gzip_write (GsfOutput *output,
size_t num_bytes, guint8 const *data)
{
GsfOutputGZip *gzip = GSF_OUTPUT_GZIP (output);
g_return_val_if_fail (data, FALSE);
gzip->stream.next_in = (unsigned char *) data;
gzip->stream.avail_in = num_bytes;
while (gzip->stream.avail_in > 0) {
int zret;
if (gzip->stream.avail_out == 0) {
if (!gzip_output_block (gzip))
return FALSE;
}
zret = deflate (&gzip->stream, Z_NO_FLUSH);
if (zret != Z_OK) {
gsf_output_set_error (output, 0,
"Unexpected compression failure");
g_warning ("Unexpected error code %d from zlib during compression.",
zret);
return FALSE;
}
}
gzip->crc = crc32 (gzip->crc, data, num_bytes);
gzip->isize += num_bytes;
if (gzip->stream.avail_out == 0) {
if (!gzip_output_block (gzip))
return FALSE;
}
return TRUE;
}
static gboolean
gsf_output_gzip_seek (G_GNUC_UNUSED GsfOutput *output,
G_GNUC_UNUSED gsf_off_t offset,
G_GNUC_UNUSED GSeekType whence)
{
return FALSE;
}
static gboolean
gsf_output_gzip_close (GsfOutput *output)
{
if (!gsf_output_error (output)) {
GsfOutputGZip *gzip = GSF_OUTPUT_GZIP (output);
if (!gzip_flush (gzip))
return FALSE;
if (!gzip->raw) {
guint8 buf[8];
GSF_LE_SET_GUINT32 (buf, gzip->crc);
GSF_LE_SET_GUINT32 (buf + 4, gzip->isize);
if (!gsf_output_write (gzip->sink, 8, buf))
return FALSE;
}
}
return TRUE;
}
static void
gsf_output_gzip_init (GObject *obj)
{
GsfOutputGZip *gzip = GSF_OUTPUT_GZIP (obj);
gzip->sink = NULL;
gzip->stream.zalloc = (alloc_func)0;
gzip->stream.zfree = (free_func)0;
gzip->stream.opaque = (voidpf)0;
gzip->stream.next_in = Z_NULL;
gzip->stream.next_out = Z_NULL;
gzip->stream.avail_in = gzip->stream.avail_out = 0;
gzip->crc = crc32 (0L, Z_NULL, 0);
gzip->isize = 0;
gzip->buf = NULL;
gzip->buf_size = 0;
}
static void
gsf_output_gzip_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GsfOutputGZip *gzip = (GsfOutputGZip *)object;
switch (property_id) {
case PROP_RAW:
g_value_set_boolean (value, gzip->raw);
break;
case PROP_SINK:
g_value_set_object (value, gzip->sink);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gsf_output_gzip_set_sink (GsfOutputGZip *gzip, GsfOutput *sink)
{
if (sink)
g_object_ref (GSF_OUTPUT (sink));
if (gzip->sink)
g_object_unref (gzip->sink);
gzip->sink = sink;
}
static void
gsf_output_gzip_set_property (GObject *object,
guint property_id,
GValue const *value,
GParamSpec *pspec)
{
GsfOutputGZip *gzip = (GsfOutputGZip *)object;
switch (property_id) {
case PROP_RAW:
gzip->raw = g_value_get_boolean (value);
break;
case PROP_SINK:
gsf_output_gzip_set_sink (gzip, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static GObject*
gsf_output_gzip_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GsfOutputGZip *gzip;
gzip = (GsfOutputGZip *)(parent_class->constructor (type,
n_construct_properties,
construct_params));
if (!gzip->sink)
gsf_output_set_error (GSF_OUTPUT (gzip),
0,
"NULL sink");
else if (!init_gzip (gzip))
gsf_output_set_error (GSF_OUTPUT (gzip),
0,
"Failed to initialize zlib structure");
else if (!gzip->raw && !gzip_output_header (gzip))
gsf_output_set_error (GSF_OUTPUT (gzip),
0,
"Failed to write gzip header");
return (GObject *)gzip;
}
static void
gsf_output_gzip_class_init (GObjectClass *gobject_class)
{
GsfOutputClass *output_class = GSF_OUTPUT_CLASS (gobject_class);
gobject_class->constructor = gsf_output_gzip_constructor;
gobject_class->finalize = gsf_output_gzip_finalize;
gobject_class->set_property = gsf_output_gzip_set_property;
gobject_class->get_property = gsf_output_gzip_get_property;
output_class->Write = gsf_output_gzip_write;
output_class->Seek = gsf_output_gzip_seek;
output_class->Close = gsf_output_gzip_close;
g_object_class_install_property
(gobject_class,
PROP_RAW,
g_param_spec_boolean ("raw", "Raw",
"Whether to write compressed data with no header/tailer.",
FALSE,
GSF_PARAM_STATIC |
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(gobject_class,
PROP_SINK,
g_param_spec_object ("sink", "Sink",
"Where the compressed data is written.",
GSF_OUTPUT_TYPE,
GSF_PARAM_STATIC |
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
parent_class = g_type_class_peek_parent (gobject_class);
}
GSF_CLASS (GsfOutputGZip, gsf_output_gzip,
gsf_output_gzip_class_init, gsf_output_gzip_init,
GSF_OUTPUT_TYPE)
syntax highlighted by Code2HTML, v. 0.9.1