| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2009 Red Hat, Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library 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 |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| * Author: Alexander Larsson <alexl@redhat.com> |
| */ |
| |
| #include "config.h" |
| |
| #include "gzlibdecompressor.h" |
| |
| #include <errno.h> |
| #include <zlib.h> |
| #include <string.h> |
| |
| #include "gfileinfo.h" |
| #include "gioerror.h" |
| #include "gioenums.h" |
| #include "gioenumtypes.h" |
| #include "glibintl.h" |
| |
| |
| enum { |
| PROP_0, |
| PROP_FORMAT, |
| PROP_FILE_INFO |
| }; |
| |
| /** |
| * SECTION:gzdecompressor |
| * @short_description: Zlib decompressor |
| * @include: gio/gio.h |
| * |
| * #GZlibDecompressor is an implementation of #GConverter that |
| * decompresses data compressed with zlib. |
| */ |
| |
| static void g_zlib_decompressor_iface_init (GConverterIface *iface); |
| |
| typedef struct { |
| gz_header gzheader; |
| char filename[257]; |
| GFileInfo *file_info; |
| } HeaderData; |
| |
| /** |
| * GZlibDecompressor: |
| * |
| * Zlib decompression |
| */ |
| struct _GZlibDecompressor |
| { |
| GObject parent_instance; |
| |
| GZlibCompressorFormat format; |
| z_stream zstream; |
| HeaderData *header_data; |
| }; |
| |
| static void |
| g_zlib_decompressor_set_gzheader (GZlibDecompressor *decompressor) |
| { |
| /* On win32, these functions were not exported before 1.2.4 */ |
| #if !defined (G_OS_WIN32) || ZLIB_VERNUM >= 0x1240 |
| if (decompressor->format != G_ZLIB_COMPRESSOR_FORMAT_GZIP) |
| return; |
| |
| if (decompressor->header_data != NULL) |
| { |
| if (decompressor->header_data->file_info) |
| g_object_unref (decompressor->header_data->file_info); |
| |
| memset (decompressor->header_data, 0, sizeof (HeaderData)); |
| } |
| else |
| { |
| decompressor->header_data = g_new0 (HeaderData, 1); |
| } |
| |
| decompressor->header_data->gzheader.name = (Bytef*) &decompressor->header_data->filename; |
| /* We keep one byte to guarantee the string is 0-terminated */ |
| decompressor->header_data->gzheader.name_max = 256; |
| |
| if (inflateGetHeader (&decompressor->zstream, &decompressor->header_data->gzheader) != Z_OK) |
| g_warning ("unexpected zlib error: %s", decompressor->zstream.msg); |
| #endif /* !G_OS_WIN32 || ZLIB >= 1.2.4 */ |
| } |
| |
| G_DEFINE_TYPE_WITH_CODE (GZlibDecompressor, g_zlib_decompressor, G_TYPE_OBJECT, |
| G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER, |
| g_zlib_decompressor_iface_init)) |
| |
| static void |
| g_zlib_decompressor_finalize (GObject *object) |
| { |
| GZlibDecompressor *decompressor; |
| |
| decompressor = G_ZLIB_DECOMPRESSOR (object); |
| |
| inflateEnd (&decompressor->zstream); |
| |
| if (decompressor->header_data != NULL) |
| { |
| if (decompressor->header_data->file_info) |
| g_object_unref (decompressor->header_data->file_info); |
| g_free (decompressor->header_data); |
| } |
| |
| G_OBJECT_CLASS (g_zlib_decompressor_parent_class)->finalize (object); |
| } |
| |
| |
| static void |
| g_zlib_decompressor_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| GZlibDecompressor *decompressor; |
| |
| decompressor = G_ZLIB_DECOMPRESSOR (object); |
| |
| switch (prop_id) |
| { |
| case PROP_FORMAT: |
| decompressor->format = g_value_get_enum (value); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| |
| } |
| |
| static void |
| g_zlib_decompressor_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| GZlibDecompressor *decompressor; |
| |
| decompressor = G_ZLIB_DECOMPRESSOR (object); |
| |
| switch (prop_id) |
| { |
| case PROP_FORMAT: |
| g_value_set_enum (value, decompressor->format); |
| break; |
| |
| case PROP_FILE_INFO: |
| if (decompressor->header_data) |
| g_value_set_object (value, decompressor->header_data->file_info); |
| else |
| g_value_set_object (value, NULL); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| g_zlib_decompressor_init (GZlibDecompressor *decompressor) |
| { |
| } |
| |
| static void |
| g_zlib_decompressor_constructed (GObject *object) |
| { |
| GZlibDecompressor *decompressor; |
| int res; |
| |
| decompressor = G_ZLIB_DECOMPRESSOR (object); |
| |
| if (decompressor->format == G_ZLIB_COMPRESSOR_FORMAT_GZIP) |
| { |
| /* + 16 for gzip */ |
| res = inflateInit2 (&decompressor->zstream, MAX_WBITS + 16); |
| } |
| else if (decompressor->format == G_ZLIB_COMPRESSOR_FORMAT_RAW) |
| { |
| /* Negative for raw */ |
| res = inflateInit2 (&decompressor->zstream, -MAX_WBITS); |
| } |
| else /* ZLIB */ |
| res = inflateInit (&decompressor->zstream); |
| |
| if (res == Z_MEM_ERROR ) |
| g_error ("GZlibDecompressor: Not enough memory for zlib use"); |
| |
| if (res != Z_OK) |
| g_warning ("unexpected zlib error: %s", decompressor->zstream.msg); |
| |
| g_zlib_decompressor_set_gzheader (decompressor); |
| } |
| |
| static void |
| g_zlib_decompressor_class_init (GZlibDecompressorClass *klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| |
| gobject_class->finalize = g_zlib_decompressor_finalize; |
| gobject_class->constructed = g_zlib_decompressor_constructed; |
| gobject_class->get_property = g_zlib_decompressor_get_property; |
| gobject_class->set_property = g_zlib_decompressor_set_property; |
| |
| g_object_class_install_property (gobject_class, |
| PROP_FORMAT, |
| g_param_spec_enum ("format", |
| P_("compression format"), |
| P_("The format of the compressed data"), |
| G_TYPE_ZLIB_COMPRESSOR_FORMAT, |
| G_ZLIB_COMPRESSOR_FORMAT_ZLIB, |
| G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | |
| G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GZlibDecompressor:file-info: |
| * |
| * A #GFileInfo containing the information found in the GZIP header |
| * of the data stream processed, or %NULL if the header was not yet |
| * fully processed, is not present at all, or the compressor's |
| * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP. |
| * |
| * Since: 2.26 |
| */ |
| g_object_class_install_property (gobject_class, |
| PROP_FILE_INFO, |
| g_param_spec_object ("file-info", |
| P_("file info"), |
| P_("File info"), |
| G_TYPE_FILE_INFO, |
| G_PARAM_READABLE | |
| G_PARAM_STATIC_STRINGS)); |
| } |
| |
| /** |
| * g_zlib_decompressor_new: |
| * @format: The format to use for the compressed data |
| * |
| * Creates a new #GZlibDecompressor. |
| * |
| * Returns: a new #GZlibDecompressor |
| * |
| * Since: 2.24 |
| **/ |
| GZlibDecompressor * |
| g_zlib_decompressor_new (GZlibCompressorFormat format) |
| { |
| GZlibDecompressor *decompressor; |
| |
| decompressor = g_object_new (G_TYPE_ZLIB_DECOMPRESSOR, |
| "format", format, |
| NULL); |
| |
| return decompressor; |
| } |
| |
| /** |
| * g_zlib_decompressor_get_file_info: |
| * @decompressor: a #GZlibDecompressor |
| * |
| * Retrieves the #GFileInfo constructed from the GZIP header data |
| * of compressed data processed by @compressor, or %NULL if @decompressor's |
| * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP, |
| * or the header data was not fully processed yet, or it not present in the |
| * data stream at all. |
| * |
| * Returns: (transfer none): a #GFileInfo, or %NULL |
| * |
| * Since: 2.26 |
| */ |
| GFileInfo * |
| g_zlib_decompressor_get_file_info (GZlibDecompressor *decompressor) |
| { |
| g_return_val_if_fail (G_IS_ZLIB_DECOMPRESSOR (decompressor), NULL); |
| |
| if (decompressor->header_data) |
| return decompressor->header_data->file_info; |
| |
| return NULL; |
| } |
| |
| static void |
| g_zlib_decompressor_reset (GConverter *converter) |
| { |
| GZlibDecompressor *decompressor = G_ZLIB_DECOMPRESSOR (converter); |
| int res; |
| |
| res = inflateReset (&decompressor->zstream); |
| if (res != Z_OK) |
| g_warning ("unexpected zlib error: %s", decompressor->zstream.msg); |
| |
| g_zlib_decompressor_set_gzheader (decompressor); |
| } |
| |
| static GConverterResult |
| g_zlib_decompressor_convert (GConverter *converter, |
| const void *inbuf, |
| gsize inbuf_size, |
| void *outbuf, |
| gsize outbuf_size, |
| GConverterFlags flags, |
| gsize *bytes_read, |
| gsize *bytes_written, |
| GError **error) |
| { |
| GZlibDecompressor *decompressor; |
| int res; |
| |
| decompressor = G_ZLIB_DECOMPRESSOR (converter); |
| |
| decompressor->zstream.next_in = (void *)inbuf; |
| decompressor->zstream.avail_in = inbuf_size; |
| |
| decompressor->zstream.next_out = outbuf; |
| decompressor->zstream.avail_out = outbuf_size; |
| |
| res = inflate (&decompressor->zstream, Z_NO_FLUSH); |
| |
| if (res == Z_DATA_ERROR || res == Z_NEED_DICT) |
| { |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, |
| _("Invalid compressed data")); |
| return G_CONVERTER_ERROR; |
| } |
| |
| if (res == Z_MEM_ERROR) |
| { |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| _("Not enough memory")); |
| return G_CONVERTER_ERROR; |
| } |
| |
| if (res == Z_STREAM_ERROR) |
| { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| _("Internal error: %s"), decompressor->zstream.msg); |
| return G_CONVERTER_ERROR; |
| } |
| |
| if (res == Z_BUF_ERROR) |
| { |
| if (flags & G_CONVERTER_FLUSH) |
| return G_CONVERTER_FLUSHED; |
| |
| /* Z_FINISH not set, so this means no progress could be made */ |
| /* We do have output space, so this should only happen if we |
| have no input but need some */ |
| |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT, |
| _("Need more input")); |
| return G_CONVERTER_ERROR; |
| } |
| |
| g_assert (res == Z_OK || res == Z_STREAM_END); |
| |
| *bytes_read = inbuf_size - decompressor->zstream.avail_in; |
| *bytes_written = outbuf_size - decompressor->zstream.avail_out; |
| |
| #if !defined (G_OS_WIN32) || ZLIB_VERNUM >= 0x1240 |
| if (decompressor->header_data != NULL && |
| decompressor->header_data->gzheader.done == 1) |
| { |
| HeaderData *data = decompressor->header_data; |
| |
| /* So we don't notify again */ |
| data->gzheader.done = 2; |
| |
| data->file_info = g_file_info_new (); |
| g_file_info_set_attribute_uint64 (data->file_info, |
| G_FILE_ATTRIBUTE_TIME_MODIFIED, |
| data->gzheader.time); |
| g_file_info_set_attribute_uint32 (data->file_info, |
| G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC, |
| 0); |
| |
| if (data->filename[0] != '\0') |
| g_file_info_set_attribute_byte_string (data->file_info, |
| G_FILE_ATTRIBUTE_STANDARD_NAME, |
| data->filename); |
| |
| g_object_notify (G_OBJECT (decompressor), "file-info"); |
| } |
| #endif /* !G_OS_WIN32 || ZLIB >= 1.2.4 */ |
| |
| if (res == Z_STREAM_END) |
| return G_CONVERTER_FINISHED; |
| return G_CONVERTER_CONVERTED; |
| } |
| |
| static void |
| g_zlib_decompressor_iface_init (GConverterIface *iface) |
| { |
| iface->convert = g_zlib_decompressor_convert; |
| iface->reset = g_zlib_decompressor_reset; |
| } |