gio/gmemoryinputstream.c - third_party/glib - Git at Google

 /* GIO - GLib Input, Output and Streaming Library
  *
  * Copyright (C) 2006-2007 Red Hat, Inc.
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  *
  * 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: Christian Kellner <gicmo@gnome.org>
  */

 #include "config.h"
 #include "gmemoryinputstream.h"
 #include "gpollableinputstream.h"
 #include "ginputstream.h"
 #include "gseekable.h"
 #include "string.h"
 #include "gtask.h"
 #include "gioerror.h"
 #include "glibintl.h"


 /**
  * GMemoryInputStream:
  *
  * `GMemoryInputStream` is a class for using arbitrary
  * memory chunks as input for GIO streaming input operations.
  *
  * As of GLib 2.34, `GMemoryInputStream` implements
  * [iface@Gio.PollableInputStream].
  */

 struct _GMemoryInputStreamPrivate {
   GSList *chunks;
   gsize   len;
   gsize   pos;
 };

 static gssize   g_memory_input_stream_read         (GInputStream         *stream,
 						    void                 *buffer,
 						    gsize                 count,
 						    GCancellable         *cancellable,
 						    GError              **error);
 static gssize   g_memory_input_stream_skip         (GInputStream         *stream,
 						    gsize                 count,
 						    GCancellable         *cancellable,
 						    GError              **error);
 static gboolean g_memory_input_stream_close        (GInputStream         *stream,
 						    GCancellable         *cancellable,
 						    GError              **error);
 static void     g_memory_input_stream_skip_async   (GInputStream         *stream,
 						    gsize                 count,
 						    int                   io_priority,
 						    GCancellable         *cancellabl,
 						    GAsyncReadyCallback   callback,
 						    gpointer              datae);
 static gssize   g_memory_input_stream_skip_finish  (GInputStream         *stream,
 						    GAsyncResult         *result,
 						    GError              **error);
 static void     g_memory_input_stream_close_async  (GInputStream         *stream,
 						    int                   io_priority,
 						    GCancellable         *cancellabl,
 						    GAsyncReadyCallback   callback,
 						    gpointer              data);
 static gboolean g_memory_input_stream_close_finish (GInputStream         *stream,
 						    GAsyncResult         *result,
 						    GError              **error);

 static void     g_memory_input_stream_seekable_iface_init (GSeekableIface  *iface);
 static goffset  g_memory_input_stream_tell                (GSeekable       *seekable);
 static gboolean g_memory_input_stream_can_seek            (GSeekable       *seekable);
 static gboolean g_memory_input_stream_seek                (GSeekable       *seekable,
                                                            goffset          offset,
                                                            GSeekType        type,
                                                            GCancellable    *cancellable,
                                                            GError         **error);
 static gboolean g_memory_input_stream_can_truncate        (GSeekable       *seekable);
 static gboolean g_memory_input_stream_truncate            (GSeekable       *seekable,
                                                            goffset          offset,
                                                            GCancellable    *cancellable,
                                                            GError         **error);

 static void     g_memory_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface);
 static gboolean g_memory_input_stream_is_readable         (GPollableInputStream *stream);
 static GSource *g_memory_input_stream_create_source       (GPollableInputStream *stream,
 							   GCancellable          *cancellable);

 static void     g_memory_input_stream_finalize            (GObject         *object);

 G_DEFINE_TYPE_WITH_CODE (GMemoryInputStream, g_memory_input_stream, G_TYPE_INPUT_STREAM,
                          G_ADD_PRIVATE (GMemoryInputStream)
                          G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
                                                 g_memory_input_stream_seekable_iface_init);
                          G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_INPUT_STREAM,
                                                 g_memory_input_stream_pollable_iface_init);
 			 )


 static void
 g_memory_input_stream_class_init (GMemoryInputStreamClass *klass)
 {
   GObjectClass *object_class;
   GInputStreamClass *istream_class;

   object_class = G_OBJECT_CLASS (klass);
   object_class->finalize     = g_memory_input_stream_finalize;

   istream_class = G_INPUT_STREAM_CLASS (klass);
   istream_class->read_fn  = g_memory_input_stream_read;
   istream_class->skip  = g_memory_input_stream_skip;
   istream_class->close_fn = g_memory_input_stream_close;

   istream_class->skip_async  = g_memory_input_stream_skip_async;
   istream_class->skip_finish  = g_memory_input_stream_skip_finish;
   istream_class->close_async = g_memory_input_stream_close_async;
   istream_class->close_finish = g_memory_input_stream_close_finish;
 }

 static void
 g_memory_input_stream_finalize (GObject *object)
 {
   GMemoryInputStream        *stream;
   GMemoryInputStreamPrivate *priv;

   stream = G_MEMORY_INPUT_STREAM (object);
   priv = stream->priv;

   g_slist_free_full (priv->chunks, (GDestroyNotify)g_bytes_unref);

   G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize (object);
 }

 static void
 g_memory_input_stream_seekable_iface_init (GSeekableIface *iface)
 {
   iface->tell         = g_memory_input_stream_tell;
   iface->can_seek     = g_memory_input_stream_can_seek;
   iface->seek         = g_memory_input_stream_seek;
   iface->can_truncate = g_memory_input_stream_can_truncate;
   iface->truncate_fn  = g_memory_input_stream_truncate;
 }

 static void
 g_memory_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface)
 {
   iface->is_readable   = g_memory_input_stream_is_readable;
   iface->create_source = g_memory_input_stream_create_source;
 }

 static void
 g_memory_input_stream_init (GMemoryInputStream *stream)
 {
   stream->priv = g_memory_input_stream_get_instance_private (stream);
 }

 /**
  * g_memory_input_stream_new:
  *
  * Creates a new empty #GMemoryInputStream.
  *
  * Returns: a new #GInputStream
  */
 GInputStream *
 g_memory_input_stream_new (void)
 {
   GInputStream *stream;

   stream = g_object_new (G_TYPE_MEMORY_INPUT_STREAM, NULL);

   return stream;
 }

 /**
  * g_memory_input_stream_new_from_data:
  * @data: (array length=len) (element-type guint8) (transfer full): input data
  * @len: length of the data, may be -1 if @data is a nul-terminated string
  * @destroy: (nullable): function that is called to free @data, or %NULL
  *
  * Creates a new #GMemoryInputStream with data in memory of a given size.
  *
  * Returns: new #GInputStream read from @data of @len bytes.
  **/
 GInputStream *
 g_memory_input_stream_new_from_data (const void     *data,
                                      gssize          len,
                                      GDestroyNotify  destroy)
 {
   GInputStream *stream;

   stream = g_memory_input_stream_new ();

   g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (stream),
                                   data, len, destroy);

   return stream;
 }

 /**
  * g_memory_input_stream_new_from_bytes:
  * @bytes: a #GBytes
  *
  * Creates a new #GMemoryInputStream with data from the given @bytes.
  *
  * Returns: new #GInputStream read from @bytes
  *
  * Since: 2.34
  **/
 GInputStream *
 g_memory_input_stream_new_from_bytes (GBytes  *bytes)
 {

   GInputStream *stream;

   stream = g_memory_input_stream_new ();

   g_memory_input_stream_add_bytes (G_MEMORY_INPUT_STREAM (stream),
 				   bytes);

   return stream;
 }

 /**
  * g_memory_input_stream_add_data:
  * @stream: a #GMemoryInputStream
  * @data: (array length=len) (element-type guint8) (transfer full): input data
  * @len: length of the data, may be -1 if @data is a nul-terminated string
  * @destroy: (nullable): function that is called to free @data, or %NULL
  *
  * Appends @data to data that can be read from the input stream
  */
 void
 g_memory_input_stream_add_data (GMemoryInputStream *stream,
                                 const void         *data,
                                 gssize              len,
                                 GDestroyNotify      destroy)
 {
   GBytes *bytes;

   if (len == -1)
     len = strlen (data);

   /* It's safe to discard the const here because we're chaining the
    * destroy callback.
    */
   bytes = g_bytes_new_with_free_func (data, len, destroy, (void*)data);

   g_memory_input_stream_add_bytes (stream, bytes);

   g_bytes_unref (bytes);
 }

 /**
  * g_memory_input_stream_add_bytes:
  * @stream: a #GMemoryInputStream
  * @bytes: input data
  *
  * Appends @bytes to data that can be read from the input stream.
  *
  * Since: 2.34
  */
 void
 g_memory_input_stream_add_bytes (GMemoryInputStream *stream,
 				 GBytes             *bytes)
 {
   GMemoryInputStreamPrivate *priv;

   g_return_if_fail (G_IS_MEMORY_INPUT_STREAM (stream));
   g_return_if_fail (bytes != NULL);

   priv = stream->priv;

   priv->chunks = g_slist_append (priv->chunks, g_bytes_ref (bytes));
   priv->len += g_bytes_get_size (bytes);
 }

 static gssize
 g_memory_input_stream_read (GInputStream  *stream,
                             void          *buffer,
                             gsize          count,
                             GCancellable  *cancellable,
                             GError       **error)
 {
   GMemoryInputStream *memory_stream;
   GMemoryInputStreamPrivate *priv;
   GSList *l;
   GBytes *chunk;
   gsize len;
   gsize offset, start, rest, size;

   memory_stream = G_MEMORY_INPUT_STREAM (stream);
   priv = memory_stream->priv;

   count = MIN (count, priv->len - priv->pos);

   offset = 0;
   for (l = priv->chunks; l; l = l->next)
     {
       chunk = (GBytes *)l->data;
       len = g_bytes_get_size (chunk);

       if (offset + len > priv->pos)
         break;

       offset += len;
     }

   start = priv->pos - offset;
   rest = count;

   for (; l && rest > 0; l = l->next)
     {
       const guint8* chunk_data;
       chunk = (GBytes *)l->data;

       chunk_data = g_bytes_get_data (chunk, &len);

       size = MIN (rest, len - start);

       memcpy ((guint8 *)buffer + (count - rest), chunk_data + start, size);
       rest -= size;

       start = 0;
     }

   priv->pos += count;

   return count;
 }

 static gssize
 g_memory_input_stream_skip (GInputStream  *stream,
                             gsize          count,
                             GCancellable  *cancellable,
                             GError       **error)
 {
   GMemoryInputStream *memory_stream;
   GMemoryInputStreamPrivate *priv;

   memory_stream = G_MEMORY_INPUT_STREAM (stream);
   priv = memory_stream->priv;

   count = MIN (count, priv->len - priv->pos);
   priv->pos += count;

   return count;
 }

 static gboolean
 g_memory_input_stream_close (GInputStream  *stream,
                              GCancellable  *cancellable,
                              GError       **error)
 {
   return TRUE;
 }

 static void
 g_memory_input_stream_skip_async (GInputStream        *stream,
                                   gsize                count,
                                   int                  io_priority,
                                   GCancellable        *cancellable,
                                   GAsyncReadyCallback  callback,
                                   gpointer             user_data)
 {
   GTask *task;
   gssize nskipped;
   GError *error = NULL;

   nskipped = G_INPUT_STREAM_GET_CLASS (stream)->skip (stream, count, cancellable, &error);
   task = g_task_new (stream, cancellable, callback, user_data);
   g_task_set_source_tag (task, g_memory_input_stream_skip_async);

   if (error)
     g_task_return_error (task, error);
   else
     g_task_return_int (task, nskipped);
   g_object_unref (task);
 }

 static gssize
 g_memory_input_stream_skip_finish (GInputStream  *stream,
                                    GAsyncResult  *result,
                                    GError       **error)
 {
   g_return_val_if_fail (g_task_is_valid (result, stream), -1);

   return g_task_propagate_int (G_TASK (result), error);
 }

 static void
 g_memory_input_stream_close_async (GInputStream        *stream,
                                    int                  io_priority,
                                    GCancellable        *cancellable,
                                    GAsyncReadyCallback  callback,
                                    gpointer             user_data)
 {
   GTask *task;

   task = g_task_new (stream, cancellable, callback, user_data);
   g_task_set_source_tag (task, g_memory_input_stream_close_async);
   g_task_return_boolean (task, TRUE);
   g_object_unref (task);
 }

 static gboolean
 g_memory_input_stream_close_finish (GInputStream  *stream,
                                     GAsyncResult  *result,
                                     GError       **error)
 {
   return TRUE;
 }

 static goffset
 g_memory_input_stream_tell (GSeekable *seekable)
 {
   GMemoryInputStream *memory_stream;
   GMemoryInputStreamPrivate *priv;

   memory_stream = G_MEMORY_INPUT_STREAM (seekable);
   priv = memory_stream->priv;

   return priv->pos;
 }

 static
 gboolean g_memory_input_stream_can_seek (GSeekable *seekable)
 {
   return TRUE;
 }

 static gboolean
 g_memory_input_stream_seek (GSeekable     *seekable,
                             goffset        offset,
                             GSeekType      type,
                             GCancellable  *cancellable,
                             GError       **error)
 {
   GMemoryInputStream *memory_stream;
   GMemoryInputStreamPrivate *priv;
   goffset absolute;

   memory_stream = G_MEMORY_INPUT_STREAM (seekable);
   priv = memory_stream->priv;

   switch (type)
     {
     case G_SEEK_CUR:
       absolute = priv->pos + offset;
       break;

     case G_SEEK_SET:
       absolute = offset;
       break;

     case G_SEEK_END:
       absolute = priv->len + offset;
       break;

     default:
       g_set_error_literal (error,
                            G_IO_ERROR,
                            G_IO_ERROR_INVALID_ARGUMENT,
                            _("Invalid GSeekType supplied"));

       return FALSE;
     }

   if (absolute < 0 || (gsize) absolute > priv->len)
     {
       g_set_error_literal (error,
                            G_IO_ERROR,
                            G_IO_ERROR_INVALID_ARGUMENT,
                            _("Invalid seek request"));
       return FALSE;
     }

   priv->pos = absolute;

   return TRUE;
 }

 static gboolean
 g_memory_input_stream_can_truncate (GSeekable *seekable)
 {
   return FALSE;
 }

 static gboolean
 g_memory_input_stream_truncate (GSeekable     *seekable,
                                 goffset        offset,
                                 GCancellable  *cancellable,
                                 GError       **error)
 {
   g_set_error_literal (error,
                        G_IO_ERROR,
                        G_IO_ERROR_NOT_SUPPORTED,
                        _("Cannot truncate GMemoryInputStream"));
   return FALSE;
 }

 static gboolean
 g_memory_input_stream_is_readable (GPollableInputStream *stream)
 {
   return TRUE;
 }

 static GSource *
 g_memory_input_stream_create_source (GPollableInputStream *stream,
 				     GCancellable         *cancellable)
 {
   GSource *base_source, *pollable_source;

   base_source = g_timeout_source_new (0);
   pollable_source = g_pollable_source_new_full (stream, base_source,
 						cancellable);
   g_source_unref (base_source);

   return pollable_source;
 }
	/* GIO - GLib Input, Output and Streaming Library
	*
	* Copyright (C) 2006-2007 Red Hat, Inc.
	*
	* SPDX-License-Identifier: LGPL-2.1-or-later
	*
	* 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: Christian Kellner <gicmo@gnome.org>
	*/

	#include "config.h"
	#include "gmemoryinputstream.h"
	#include "gpollableinputstream.h"
	#include "ginputstream.h"
	#include "gseekable.h"
	#include "string.h"
	#include "gtask.h"
	#include "gioerror.h"
	#include "glibintl.h"


	/**
	* GMemoryInputStream:
	*
	* `GMemoryInputStream` is a class for using arbitrary
	* memory chunks as input for GIO streaming input operations.
	*
	* As of GLib 2.34, `GMemoryInputStream` implements
	* [iface@Gio.PollableInputStream].
	*/

	struct _GMemoryInputStreamPrivate {
	GSList *chunks;
	gsize len;
	gsize pos;
	};

	static gssize g_memory_input_stream_read (GInputStream *stream,
	void *buffer,
	gsize count,
	GCancellable *cancellable,
	GError **error);
	static gssize g_memory_input_stream_skip (GInputStream *stream,
	gsize count,
	GCancellable *cancellable,
	GError **error);
	static gboolean g_memory_input_stream_close (GInputStream *stream,
	GCancellable *cancellable,
	GError **error);
	static void g_memory_input_stream_skip_async (GInputStream *stream,
	gsize count,
	int io_priority,
	GCancellable *cancellabl,
	GAsyncReadyCallback callback,
	gpointer datae);
	static gssize g_memory_input_stream_skip_finish (GInputStream *stream,
	GAsyncResult *result,
	GError **error);
	static void g_memory_input_stream_close_async (GInputStream *stream,
	int io_priority,
	GCancellable *cancellabl,
	GAsyncReadyCallback callback,
	gpointer data);
	static gboolean g_memory_input_stream_close_finish (GInputStream *stream,
	GAsyncResult *result,
	GError **error);

	static void g_memory_input_stream_seekable_iface_init (GSeekableIface *iface);
	static goffset g_memory_input_stream_tell (GSeekable *seekable);
	static gboolean g_memory_input_stream_can_seek (GSeekable *seekable);
	static gboolean g_memory_input_stream_seek (GSeekable *seekable,
	goffset offset,
	GSeekType type,
	GCancellable *cancellable,
	GError **error);
	static gboolean g_memory_input_stream_can_truncate (GSeekable *seekable);
	static gboolean g_memory_input_stream_truncate (GSeekable *seekable,
	goffset offset,
	GCancellable *cancellable,
	GError **error);

	static void g_memory_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface);
	static gboolean g_memory_input_stream_is_readable (GPollableInputStream *stream);
	static GSource g_memory_input_stream_create_source (GPollableInputStream stream,
	GCancellable *cancellable);

	static void g_memory_input_stream_finalize (GObject *object);

	G_DEFINE_TYPE_WITH_CODE (GMemoryInputStream, g_memory_input_stream, G_TYPE_INPUT_STREAM,
	G_ADD_PRIVATE (GMemoryInputStream)
	G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
	g_memory_input_stream_seekable_iface_init);
	G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_INPUT_STREAM,
	g_memory_input_stream_pollable_iface_init);
	)


	static void
	g_memory_input_stream_class_init (GMemoryInputStreamClass *klass)
	{
	GObjectClass *object_class;
	GInputStreamClass *istream_class;

	object_class = G_OBJECT_CLASS (klass);
	object_class->finalize = g_memory_input_stream_finalize;

	istream_class = G_INPUT_STREAM_CLASS (klass);
	istream_class->read_fn = g_memory_input_stream_read;
	istream_class->skip = g_memory_input_stream_skip;
	istream_class->close_fn = g_memory_input_stream_close;

	istream_class->skip_async = g_memory_input_stream_skip_async;
	istream_class->skip_finish = g_memory_input_stream_skip_finish;
	istream_class->close_async = g_memory_input_stream_close_async;
	istream_class->close_finish = g_memory_input_stream_close_finish;
	}

	static void
	g_memory_input_stream_finalize (GObject *object)
	{
	GMemoryInputStream *stream;
	GMemoryInputStreamPrivate *priv;

	stream = G_MEMORY_INPUT_STREAM (object);
	priv = stream->priv;

	g_slist_free_full (priv->chunks, (GDestroyNotify)g_bytes_unref);

	G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize (object);
	}

	static void
	g_memory_input_stream_seekable_iface_init (GSeekableIface *iface)
	{
	iface->tell = g_memory_input_stream_tell;
	iface->can_seek = g_memory_input_stream_can_seek;
	iface->seek = g_memory_input_stream_seek;
	iface->can_truncate = g_memory_input_stream_can_truncate;
	iface->truncate_fn = g_memory_input_stream_truncate;
	}

	static void
	g_memory_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface)
	{
	iface->is_readable = g_memory_input_stream_is_readable;
	iface->create_source = g_memory_input_stream_create_source;
	}

	static void
	g_memory_input_stream_init (GMemoryInputStream *stream)
	{
	stream->priv = g_memory_input_stream_get_instance_private (stream);
	}

	/**
	* g_memory_input_stream_new:
	*
	* Creates a new empty #GMemoryInputStream.
	*
	* Returns: a new #GInputStream
	*/
	GInputStream *
	g_memory_input_stream_new (void)
	{
	GInputStream *stream;

	stream = g_object_new (G_TYPE_MEMORY_INPUT_STREAM, NULL);

	return stream;
	}

	/**
	* g_memory_input_stream_new_from_data:
	* @data: (array length=len) (element-type guint8) (transfer full): input data
	* @len: length of the data, may be -1 if @data is a nul-terminated string
	* @destroy: (nullable): function that is called to free @data, or %NULL
	*
	* Creates a new #GMemoryInputStream with data in memory of a given size.
	*
	* Returns: new #GInputStream read from @data of @len bytes.
	**/
	GInputStream *
	g_memory_input_stream_new_from_data (const void *data,
	gssize len,
	GDestroyNotify destroy)
	{
	GInputStream *stream;

	stream = g_memory_input_stream_new ();

	g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (stream),
	data, len, destroy);

	return stream;
	}

	/**
	* g_memory_input_stream_new_from_bytes:
	* @bytes: a #GBytes
	*
	* Creates a new #GMemoryInputStream with data from the given @bytes.
	*
	* Returns: new #GInputStream read from @bytes
	*
	* Since: 2.34
	**/
	GInputStream *
	g_memory_input_stream_new_from_bytes (GBytes *bytes)
	{

	GInputStream *stream;

	stream = g_memory_input_stream_new ();

	g_memory_input_stream_add_bytes (G_MEMORY_INPUT_STREAM (stream),
	bytes);

	return stream;
	}

	/**
	* g_memory_input_stream_add_data:
	* @stream: a #GMemoryInputStream
	* @data: (array length=len) (element-type guint8) (transfer full): input data
	* @len: length of the data, may be -1 if @data is a nul-terminated string
	* @destroy: (nullable): function that is called to free @data, or %NULL
	*
	* Appends @data to data that can be read from the input stream
	*/
	void
	g_memory_input_stream_add_data (GMemoryInputStream *stream,
	const void *data,
	gssize len,
	GDestroyNotify destroy)
	{
	GBytes *bytes;

	if (len == -1)
	len = strlen (data);

	/* It's safe to discard the const here because we're chaining the
	* destroy callback.
	*/
	bytes = g_bytes_new_with_free_func (data, len, destroy, (void*)data);

	g_memory_input_stream_add_bytes (stream, bytes);

	g_bytes_unref (bytes);
	}

	/**
	* g_memory_input_stream_add_bytes:
	* @stream: a #GMemoryInputStream
	* @bytes: input data
	*
	* Appends @bytes to data that can be read from the input stream.
	*
	* Since: 2.34
	*/
	void
	g_memory_input_stream_add_bytes (GMemoryInputStream *stream,
	GBytes *bytes)
	{
	GMemoryInputStreamPrivate *priv;

	g_return_if_fail (G_IS_MEMORY_INPUT_STREAM (stream));
	g_return_if_fail (bytes != NULL);

	priv = stream->priv;

	priv->chunks = g_slist_append (priv->chunks, g_bytes_ref (bytes));
	priv->len += g_bytes_get_size (bytes);
	}

	static gssize
	g_memory_input_stream_read (GInputStream *stream,
	void *buffer,
	gsize count,
	GCancellable *cancellable,
	GError **error)
	{
	GMemoryInputStream *memory_stream;
	GMemoryInputStreamPrivate *priv;
	GSList *l;
	GBytes *chunk;
	gsize len;
	gsize offset, start, rest, size;

	memory_stream = G_MEMORY_INPUT_STREAM (stream);
	priv = memory_stream->priv;

	count = MIN (count, priv->len - priv->pos);

	offset = 0;
	for (l = priv->chunks; l; l = l->next)
	{
	chunk = (GBytes *)l->data;
	len = g_bytes_get_size (chunk);

	if (offset + len > priv->pos)
	break;

	offset += len;
	}

	start = priv->pos - offset;
	rest = count;

	for (; l && rest > 0; l = l->next)
	{
	const guint8* chunk_data;
	chunk = (GBytes *)l->data;

	chunk_data = g_bytes_get_data (chunk, &len);

	size = MIN (rest, len - start);

	memcpy ((guint8 *)buffer + (count - rest), chunk_data + start, size);
	rest -= size;

	start = 0;
	}

	priv->pos += count;

	return count;
	}

	static gssize
	g_memory_input_stream_skip (GInputStream *stream,
	gsize count,
	GCancellable *cancellable,
	GError **error)
	{
	GMemoryInputStream *memory_stream;
	GMemoryInputStreamPrivate *priv;

	memory_stream = G_MEMORY_INPUT_STREAM (stream);
	priv = memory_stream->priv;

	count = MIN (count, priv->len - priv->pos);
	priv->pos += count;

	return count;
	}

	static gboolean
	g_memory_input_stream_close (GInputStream *stream,
	GCancellable *cancellable,
	GError **error)
	{
	return TRUE;
	}

	static void
	g_memory_input_stream_skip_async (GInputStream *stream,
	gsize count,
	int io_priority,
	GCancellable *cancellable,
	GAsyncReadyCallback callback,
	gpointer user_data)
	{
	GTask *task;
	gssize nskipped;
	GError *error = NULL;

	nskipped = G_INPUT_STREAM_GET_CLASS (stream)->skip (stream, count, cancellable, &error);
	task = g_task_new (stream, cancellable, callback, user_data);
	g_task_set_source_tag (task, g_memory_input_stream_skip_async);

	if (error)
	g_task_return_error (task, error);
	else
	g_task_return_int (task, nskipped);
	g_object_unref (task);
	}

	static gssize
	g_memory_input_stream_skip_finish (GInputStream *stream,
	GAsyncResult *result,
	GError **error)
	{
	g_return_val_if_fail (g_task_is_valid (result, stream), -1);

	return g_task_propagate_int (G_TASK (result), error);
	}

	static void
	g_memory_input_stream_close_async (GInputStream *stream,
	int io_priority,
	GCancellable *cancellable,
	GAsyncReadyCallback callback,
	gpointer user_data)
	{
	GTask *task;

	task = g_task_new (stream, cancellable, callback, user_data);
	g_task_set_source_tag (task, g_memory_input_stream_close_async);
	g_task_return_boolean (task, TRUE);
	g_object_unref (task);
	}

	static gboolean
	g_memory_input_stream_close_finish (GInputStream *stream,
	GAsyncResult *result,
	GError **error)
	{
	return TRUE;
	}

	static goffset
	g_memory_input_stream_tell (GSeekable *seekable)
	{
	GMemoryInputStream *memory_stream;
	GMemoryInputStreamPrivate *priv;

	memory_stream = G_MEMORY_INPUT_STREAM (seekable);
	priv = memory_stream->priv;

	return priv->pos;
	}

	static
	gboolean g_memory_input_stream_can_seek (GSeekable *seekable)
	{
	return TRUE;
	}

	static gboolean
	g_memory_input_stream_seek (GSeekable *seekable,
	goffset offset,
	GSeekType type,
	GCancellable *cancellable,
	GError **error)
	{
	GMemoryInputStream *memory_stream;
	GMemoryInputStreamPrivate *priv;
	goffset absolute;

	memory_stream = G_MEMORY_INPUT_STREAM (seekable);
	priv = memory_stream->priv;

	switch (type)
	{
	case G_SEEK_CUR:
	absolute = priv->pos + offset;
	break;

	case G_SEEK_SET:
	absolute = offset;
	break;

	case G_SEEK_END:
	absolute = priv->len + offset;
	break;

	default:
	g_set_error_literal (error,
	G_IO_ERROR,
	G_IO_ERROR_INVALID_ARGUMENT,
	_("Invalid GSeekType supplied"));

	return FALSE;
	}

	if (absolute < 0 \|\| (gsize) absolute > priv->len)
	{
	g_set_error_literal (error,
	G_IO_ERROR,
	G_IO_ERROR_INVALID_ARGUMENT,
	_("Invalid seek request"));
	return FALSE;
	}

	priv->pos = absolute;

	return TRUE;
	}

	static gboolean
	g_memory_input_stream_can_truncate (GSeekable *seekable)
	{
	return FALSE;
	}

	static gboolean
	g_memory_input_stream_truncate (GSeekable *seekable,
	goffset offset,
	GCancellable *cancellable,
	GError **error)
	{
	g_set_error_literal (error,
	G_IO_ERROR,
	G_IO_ERROR_NOT_SUPPORTED,
	_("Cannot truncate GMemoryInputStream"));
	return FALSE;
	}

	static gboolean
	g_memory_input_stream_is_readable (GPollableInputStream *stream)
	{
	return TRUE;
	}

	static GSource *
	g_memory_input_stream_create_source (GPollableInputStream *stream,
	GCancellable *cancellable)
	{
	GSource base_source, pollable_source;

	base_source = g_timeout_source_new (0);
	pollable_source = g_pollable_source_new_full (stream, base_source,
	cancellable);
	g_source_unref (base_source);

	return pollable_source;
	}