2010-09-06  Sergio Villar Senin  <svillar@igalia.com>

        Reviewed by NOBODY (OOPS!).

        [GTK] Add HTTP caching support

        https://bugs.webkit.org/show_bug.cgi?id=44261

        * GNUmakefile.am: added paths for soup HTTP cache code

        * autotools/webkit.m4: upgraded required glib version

	-I$(srcdir)/WebCore/platform/network/soup/cache \

2010-09-06  Sergio Villar Senin  <svillar@igalia.com>

        Reviewed by NOBODY (OOPS!).

        [GTK] Add HTTP caching support

        https://bugs.webkit.org/show_bug.cgi?id=44261

        * GNUmakefile.am:

        * platform/network/ResourceHandleInternal.h:

        (WebCore::ResourceHandleInternal::ResourceHandleInternal):

        * platform/network/soup/ResourceHandleSoup.cpp:

        (WebCore::ResourceHandleInternal::~ResourceHandleInternal):

        (WebCore::ResourceHandle::~ResourceHandle):

        (WebCore::restartedCallback):

        (WebCore::gotChunkCallback):

        (WebCore::parseDataUrl):

        (WebCore::cleanupSoupRequestOperation):

        (WebCore::sendRequestCallback):

        (WebCore::startHttp):

        * platform/network/soup/ResourceRequest.h:

        * platform/network/soup/ResourceRequestSoup.cpp:

        (WebCore::ResourceRequest::updateSoupMessage):

        * platform/network/soup/cache/soup-directory-input-stream.c: Added.

        (soup_directory_input_stream_parse_info):

        (soup_directory_input_stream_read_next_file):

        (soup_directory_input_stream_read):

        (soup_directory_input_stream_close):

        (soup_directory_input_stream_class_init):

        (soup_directory_input_stream_init):

        (soup_directory_input_stream_new):

        * platform/network/soup/cache/soup-directory-input-stream.h: Added.

        * platform/network/soup/cache/soup-http-input-stream.c: Added.

        (soup_http_input_stream_finalize):

        (soup_http_input_stream_class_init):

        (soup_http_input_stream_seekable_iface_init):

        (soup_http_input_stream_init):

        (soup_http_input_stream_queue_message):

        (soup_http_input_stream_new):

        (soup_http_input_stream_got_headers):

        (soup_http_input_stream_got_chunk):

        (soup_http_input_stream_finished):

        (soup_http_input_stream_cancelled):

        (soup_http_input_stream_prepare_for_io):

        (soup_http_input_stream_done_io):

        (set_error_if_http_failed):

        (read_from_leftover):

        (soup_http_input_stream_send_internal):

        (send_sync_finished):

        (soup_http_input_stream_send):

        (soup_http_input_stream_read):

        (soup_http_input_stream_close):

        (wrapper_callback):

        (send_async_thread):

        (soup_http_input_stream_send_async_in_thread):

        (send_async_finished):

        (soup_http_input_stream_send_async_internal):

        (soup_http_input_stream_send_async):

        (soup_http_input_stream_send_finish):

        (read_async_done):

        (soup_http_input_stream_read_async):

        (soup_http_input_stream_read_finish):

        (soup_http_input_stream_close_async):

        (soup_http_input_stream_close_finish):

        (soup_http_input_stream_tell):

        (soup_http_input_stream_can_seek):

        (soup_http_input_stream_seek):

        (soup_http_input_stream_can_truncate):

        (soup_http_input_stream_truncate):

        (soup_http_input_stream_get_message):

        * platform/network/soup/cache/soup-http-input-stream.h: Added.

        * platform/network/soup/cache/soup-request-data.c: Added.

        (soup_request_data_init):

        (soup_request_data_finalize):

        (soup_request_data_check_uri):

        (uri_decoded_copy):

        (soup_request_data_send):

        (soup_request_data_get_content_length):

        (soup_request_data_get_content_type):

        (soup_request_data_class_init):

        * platform/network/soup/cache/soup-request-data.h: Added.

        * platform/network/soup/cache/soup-request-file.c: Added.

        (soup_request_file_get_file):

        (soup_request_file_init):

        (soup_request_file_finalize):

        (soup_request_file_check_uri):

        (soup_request_file_ftp_main_loop_quit):

        (soup_request_file_ensure_file_ftp):

        (soup_request_file_ensure_file):

        (soup_request_file_send):

        (soup_request_file_send_async_thread):

        (soup_request_file_send_async):

        (soup_request_file_send_finish):

        (soup_request_file_get_content_length):

        (soup_request_file_get_content_type):

        (soup_request_file_class_init):

        * platform/network/soup/cache/soup-request-file.h: Added.

        * platform/network/soup/cache/soup-request-http.c: Added.

        (soup_request_http_get_message):

        (soup_request_http_init):

        (soup_request_http_check_uri):

        (soup_request_http_finalize):

        (soup_request_http_send):

        (sent_async):

        (conditional_get_ready_cb):

        (send_async_cb):

        (soup_request_http_send_async):

        (soup_request_http_send_finish):

        (soup_request_http_get_content_length):

        (soup_request_http_get_content_type):

        (soup_request_http_class_init):

        * platform/network/soup/cache/soup-request-http.h: Added.

        * platform/network/soup/cache/soup-request.c: Added.

        (soup_request_init):

        (soup_request_finalize):

        (soup_request_set_property):

        (soup_request_get_property):

        (soup_request_initable_init):

        (soup_request_default_check_uri):

        (soup_request_default_send_async):

        (soup_request_default_send_finish):

        (soup_request_send):

        (soup_request_send_async):

        (soup_request_send_finish):

        (soup_request_class_init):

        (soup_request_initable_interface_init):

        (soup_request_get_uri):

        (soup_request_get_session):

        (soup_request_get_content_length):

        (soup_request_get_content_type):

        * platform/network/soup/cache/soup-request.h: Added.

        * platform/network/soup/cache/soup-requester.c: Added.

        (soup_requester_init):

        (finalize):

        (soup_requester_class_init):

        (init_request_types):

        (soup_requester_new):

        (soup_requester_request):

        (soup_requester_request_uri):

        (soup_scheme_is_valid):

        (soup_requester_add_protocol):

        (soup_requester_remove_protocol):

        (soup_error_quark):

        * platform/network/soup/cache/soup-requester.h: Added.

        * platform/network/soup/cache/webkit/soup-cache-private.h: Added.

        * platform/network/soup/cache/webkit/soup-cache.c: Added.

        (get_cacheability):

        (webkit_soup_cache_entry_free):

        (copy_headers):

        (update_headers):

        (webkit_soup_cache_entry_get_current_age):

        (webkit_soup_cache_entry_is_fresh_enough):

        (soup_message_get_cache_key):

        (webkit_soup_cache_entry_set_freshness):

        (webkit_soup_cache_entry_new):

        (webkit_soup_cache_writing_fixture_free):

        (close_ready_cb):

        (write_ready_cb):

        (msg_got_chunk_cb):

        (msg_got_body_cb):

        (webkit_soup_cache_entry_delete):

        (lru_compare_func):

        (cache_accepts_entries_of_size):

        (make_room_for_new_entry):

        (webkit_soup_cache_entry_insert_by_key):

        (msg_restarted_cb):

        (append_to_ready_cb):

        (msg_got_headers_cb):

        (webkit_soup_cache_send_response):

        (request_started):

        (attach):

        (webkit_soup_cache_session_feature_init):

        (webkit_soup_cache_init):

        (webkit_soup_cache_finalize):

        (webkit_soup_cache_set_property):

        (webkit_soup_cache_get_property):

        (webkit_soup_cache_constructed):

        (webkit_soup_cache_type_get_type):

        (webkit_soup_cache_class_init):

        (webkit_soup_cache_new):

        (webkit_soup_cache_has_response):

        (webkit_soup_cache_get_cacheability):

        (force_flush_timeout):

        (webkit_soup_cache_flush):

        (remove_cache_item):

        (webkit_soup_cache_clear):

        (webkit_soup_cache_generate_conditional_request):

        (pack_entry):

        (webkit_soup_cache_dump):

        (webkit_soup_cache_load):

        (webkit_soup_cache_set_max_size):

        (webkit_soup_cache_get_max_size):

        * platform/network/soup/cache/webkit/soup-cache.h: Added.

	WebCore/platform/network/soup/cache/soup-directory-input-stream.c \

	WebCore/platform/network/soup/cache/soup-directory-input-stream.h \

	WebCore/platform/network/soup/cache/soup-http-input-stream.c \

	WebCore/platform/network/soup/cache/soup-http-input-stream.h \

	WebCore/platform/network/soup/cache/soup-request.c \

	WebCore/platform/network/soup/cache/soup-request-data.c \

	WebCore/platform/network/soup/cache/soup-request-data.h \

	WebCore/platform/network/soup/cache/soup-requester.c \

	WebCore/platform/network/soup/cache/soup-requester.h \

	WebCore/platform/network/soup/cache/soup-request-file.c \

	WebCore/platform/network/soup/cache/soup-request-file.h \

	WebCore/platform/network/soup/cache/soup-request.h \

	WebCore/platform/network/soup/cache/soup-request-http.c \

	WebCore/platform/network/soup/cache/soup-request-http.h \

	WebCore/platform/network/soup/cache/webkit/soup-cache.c \

	WebCore/platform/network/soup/cache/webkit/soup-cache.h \

/*

 * Copyright (C) 2008 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "soup-directory-input-stream.h"

#include <libsoup/soup.h>

#include <stdio.h>

#include <string.h>

#define INIT_STRING "<html><head><title>OMG!</title></head><body><table>"

#define EXIT_STRING "</table></html>"

G_DEFINE_TYPE (SoupDirectoryInputStream, soup_directory_input_stream, G_TYPE_INPUT_STREAM)

static SoupBuffer *

soup_directory_input_stream_parse_info (SoupDirectoryInputStream * stream,

					GFileInfo * info)

{

	SoupBuffer *buffer;

	GString *string;

	const char *s;

	char *escaped, *path, *xml_string;

	if (!g_file_info_get_name (info))

		return NULL;

	s = g_file_info_get_display_name (info);

	if (!s) {

		s = g_file_info_get_name (info);

		/* FIXME: convert somehow? */

		if (!g_utf8_validate (s, -1, NULL))

			return NULL;

	}

	string = g_string_new ("<tr>");

	xml_string = g_markup_escape_text (s, -1);

	escaped = g_uri_escape_string (g_file_info_get_name (info), NULL, FALSE);

	path = g_strconcat (stream->uri, "/", escaped, NULL);

	g_free (escaped);

	g_string_append_printf (string, "<td><a href=\"%s\">%s</a></td>", path, xml_string);

	g_free (path);

	g_free (xml_string);

	g_string_append (string, "</tr>");

	buffer = soup_buffer_new (SOUP_MEMORY_TAKE, string->str, string->len);

	g_string_free (string, FALSE);

	return buffer;

}

static SoupBuffer *

soup_directory_input_stream_read_next_file (SoupDirectoryInputStream  *stream,

					    GCancellable              *cancellable,

					    GError                   **error)

{

	GFileInfo *info;

	SoupBuffer *buffer;

	GError *err = NULL;

	do {

		info = g_file_enumerator_next_file (stream->enumerator, cancellable, &err);

		if (info == NULL) {

			if (err) {

				g_propagate_error (error, err);

				return NULL;

			} else if (!stream->done) {

				stream->done = TRUE;

				return soup_buffer_new (SOUP_MEMORY_STATIC,

							EXIT_STRING,

							sizeof (EXIT_STRING));

			} else {

				return NULL;

			}

		}

		buffer = soup_directory_input_stream_parse_info (stream, info);

	} while (buffer == NULL);

	return buffer;

}

static gssize

soup_directory_input_stream_read (GInputStream  *input,

				  void          *buffer,

				  gsize count,

				  GCancellable  *cancellable,

				  GError       **error)

{

	SoupDirectoryInputStream *stream = SOUP_DIRECTORY_INPUT_STREAM (input);

	gssize total, size;

	for (total = 0; total < count; total += size) {

		if (stream->buffer == NULL) {

			stream->buffer = soup_directory_input_stream_read_next_file (stream, cancellable, error);

			if (stream->buffer == NULL) {

				/* FIXME: Is this correct or should we forward the error? */

				if (total)

					g_clear_error (error);

				return total;

			}

		}

		size = MIN (stream->buffer->length, count - total);

		memcpy ((char *)buffer + total, stream->buffer->data, size);

		if (size == stream->buffer->length) {

			soup_buffer_free (stream->buffer);

			stream->buffer = NULL;

		} else {

			SoupBuffer *sub = soup_buffer_new_subbuffer (stream->buffer,

								     size,

								     stream->buffer->length - size);

			soup_buffer_free (stream->buffer);

			stream->buffer = sub;

		}

	}

	return total;

}

static gboolean

soup_directory_input_stream_close (GInputStream  *input,

				   GCancellable  *cancellable,

				   GError       **error)

{

	SoupDirectoryInputStream *stream = SOUP_DIRECTORY_INPUT_STREAM (input);

	gboolean result;

	if (stream->buffer) {

		soup_buffer_free (stream->buffer);

		stream->buffer = NULL;

	}

	result = g_file_enumerator_close (stream->enumerator,

					  cancellable,

					  error);

	g_object_unref (stream->enumerator);

	stream->enumerator = NULL;

	g_free (stream->uri);

	stream->uri = NULL;

	return result;

}

static void

soup_directory_input_stream_class_init (SoupDirectoryInputStreamClass *stream_class)

{

	GInputStreamClass *inputstream_class = G_INPUT_STREAM_CLASS (stream_class);

	inputstream_class->read_fn = soup_directory_input_stream_read;

	inputstream_class->close_fn = soup_directory_input_stream_close;

}

static void

soup_directory_input_stream_init (SoupDirectoryInputStream *stream)

{

	stream->buffer = soup_buffer_new (SOUP_MEMORY_STATIC,

					  INIT_STRING,

					  sizeof (INIT_STRING));

}

GInputStream *

soup_directory_input_stream_new (GFileEnumerator *enumerator,

				 SoupURI         *uri)

{

	GInputStream *stream;

	g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);

	g_return_val_if_fail (uri != NULL, NULL);

	stream = g_object_new (SOUP_TYPE_DIRECTORY_INPUT_STREAM, NULL);

	SOUP_DIRECTORY_INPUT_STREAM (stream)->enumerator = g_object_ref (enumerator);

	SOUP_DIRECTORY_INPUT_STREAM (stream)->uri = soup_uri_to_string (uri, FALSE);

	return stream;

}

/*

 * Copyright (C) 2010 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifndef SOUP_DIRECTORY_INPUT_STREAM_H

#define SOUP_DIRECTORY_INPUT_STREAM_H 1

#include <gio/gio.h>

#include <libsoup/soup-types.h>

#include <libsoup/soup-message-body.h>

G_BEGIN_DECLS

#define SOUP_TYPE_DIRECTORY_INPUT_STREAM            (soup_directory_input_stream_get_type ())

#define SOUP_DIRECTORY_INPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_DIRECTORY_INPUT_STREAM, SoupDirectoryInputStream))

#define SOUP_DIRECTORY_INPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_DIRECTORY_INPUT_STREAM, SoupDirectoryInputStreamClass))

#define SOUP_IS_DIRECTORY_INPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_DIRECTORY_INPUT_STREAM))

#define SOUP_IS_DIRECTORY_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_DIRECTORY_INPUT_STREAM))

#define SOUP_DIRECTORY_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_DIRECTORY_INPUT_STREAM, SoupDirectoryInputStreamClass))

typedef struct _SoupDirectoryInputStream SoupDirectoryInputStream;

typedef struct _SoupDirectoryInputStreamClass SoupDirectoryInputStreamClass;

struct _SoupDirectoryInputStream {

	GInputStream parent;

	GFileEnumerator *enumerator;

	char *uri;

	SoupBuffer *buffer;

	gboolean done;

};

struct _SoupDirectoryInputStreamClass {

	GInputStreamClass parent_class;

};

GType          soup_directory_input_stream_get_type (void);

GInputStream *soup_directory_input_stream_new (GFileEnumerator *enumerator,

					       SoupURI         *uri);

G_END_DECLS

#endif /* SOUP_DIRECTORY_INPUT_STREAM_H */

/* soup-input-stream.c, based on gsocketinputstream.c

 *

 * Copyright (C) 2006-2007 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * 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 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, write to the

 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include <config.h>

#include <string.h>

#include <glib.h>

#include <gio/gio.h>

#include <libsoup/soup.h>

#include "soup-http-input-stream.h"

static void soup_http_input_stream_seekable_iface_init (GSeekableIface *seekable_iface);

G_DEFINE_TYPE_WITH_CODE (SoupHTTPInputStream, soup_http_input_stream, G_TYPE_INPUT_STREAM,

			 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,

						soup_http_input_stream_seekable_iface_init))

typedef void (*SoupHTTPInputStreamCallback)(GInputStream *);

typedef struct {

	SoupSession *session;

	GMainContext *async_context;

	SoupMessage *msg;

	gboolean got_headers, finished;

	goffset offset;

	GCancellable *cancellable;

	GSource *cancel_watch;

	SoupHTTPInputStreamCallback got_headers_cb;

	SoupHTTPInputStreamCallback got_chunk_cb;

	SoupHTTPInputStreamCallback finished_cb;

	SoupHTTPInputStreamCallback cancelled_cb;

	guchar *leftover_buffer;

	gsize leftover_bufsize, leftover_offset;

	guchar *caller_buffer;

	gsize caller_bufsize, caller_nread;

	GAsyncReadyCallback outstanding_callback;

	GSimpleAsyncResult *result;

} SoupHTTPInputStreamPrivate;

#define SOUP_HTTP_INPUT_STREAM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_HTTP_INPUT_STREAM, SoupHTTPInputStreamPrivate))

static gssize   soup_http_input_stream_read (GInputStream         *stream,

					     void                 *buffer,

					     gsize count,

					     GCancellable         *cancellable,

					     GError              **error);

static gboolean soup_http_input_stream_close (GInputStream         *stream,

					      GCancellable         *cancellable,

					      GError              **error);

static void     soup_http_input_stream_read_async (GInputStream         *stream,

						   void                 *buffer,

						   gsize count,

						   int io_priority,

						   GCancellable         *cancellable,

						   GAsyncReadyCallback callback,

						   gpointer data);

static gssize   soup_http_input_stream_read_finish (GInputStream         *stream,

						    GAsyncResult         *result,

						    GError              **error);

static void     soup_http_input_stream_close_async (GInputStream         *stream,

						    int io_priority,

						    GCancellable         *cancellable,

						    GAsyncReadyCallback callback,

						    gpointer data);

static gboolean soup_http_input_stream_close_finish (GInputStream         *stream,

						     GAsyncResult         *result,

						     GError              **error);

static goffset  soup_http_input_stream_tell (GSeekable            *seekable);

static gboolean soup_http_input_stream_can_seek (GSeekable            *seekable);

static gboolean soup_http_input_stream_seek (GSeekable            *seekable,

					     goffset offset,

					     GSeekType type,

					     GCancellable         *cancellable,

					     GError              **error);

static gboolean soup_http_input_stream_can_truncate (GSeekable            *seekable);

static gboolean soup_http_input_stream_truncate (GSeekable            *seekable,

						 goffset offset,

						 GCancellable         *cancellable,

						 GError              **error);

static void soup_http_input_stream_got_headers (SoupMessage *msg, gpointer stream);

static void soup_http_input_stream_got_chunk (SoupMessage *msg, SoupBuffer *chunk, gpointer stream);

static void soup_http_input_stream_finished (SoupMessage *msg, gpointer stream);

static void

soup_http_input_stream_finalize (GObject *object)

{

	SoupHTTPInputStream *stream = SOUP_HTTP_INPUT_STREAM (object);

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	g_object_unref (priv->session);

	g_signal_handlers_disconnect_by_func (priv->msg, G_CALLBACK (soup_http_input_stream_got_headers), stream);

	g_signal_handlers_disconnect_by_func (priv->msg, G_CALLBACK (soup_http_input_stream_got_chunk), stream);

	g_signal_handlers_disconnect_by_func (priv->msg, G_CALLBACK (soup_http_input_stream_finished), stream);

	g_object_unref (priv->msg);

	g_free (priv->leftover_buffer);

	if (G_OBJECT_CLASS (soup_http_input_stream_parent_class)->finalize)

		(*G_OBJECT_CLASS (soup_http_input_stream_parent_class)->finalize)(object);

}

static void

soup_http_input_stream_class_init (SoupHTTPInputStreamClass *klass)

{

	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

	GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass);

	g_type_class_add_private (klass, sizeof (SoupHTTPInputStreamPrivate));

	gobject_class->finalize = soup_http_input_stream_finalize;

	stream_class->read_fn = soup_http_input_stream_read;

	stream_class->close_fn = soup_http_input_stream_close;

	stream_class->read_async = soup_http_input_stream_read_async;

	stream_class->read_finish = soup_http_input_stream_read_finish;

	stream_class->close_async = soup_http_input_stream_close_async;

	stream_class->close_finish = soup_http_input_stream_close_finish;

}

static void

soup_http_input_stream_seekable_iface_init (GSeekableIface *seekable_iface)

{

	seekable_iface->tell = soup_http_input_stream_tell;

	seekable_iface->can_seek = soup_http_input_stream_can_seek;

	seekable_iface->seek = soup_http_input_stream_seek;

	seekable_iface->can_truncate = soup_http_input_stream_can_truncate;

	seekable_iface->truncate_fn = soup_http_input_stream_truncate;

}

static void

soup_http_input_stream_init (SoupHTTPInputStream *stream)

{

	;

}

static void

soup_http_input_stream_queue_message (SoupHTTPInputStream *stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	priv->got_headers = priv->finished = FALSE;

	/* Add an extra ref since soup_session_queue_message steals one */

	g_object_ref (priv->msg);

	soup_session_queue_message (priv->session, priv->msg, NULL, NULL);

}

/**

 * soup_http_input_stream_new:

 * @session: the #SoupSession to use

 * @msg: the #SoupMessage whose response will be streamed

 *

 * Prepares to send @msg over @session, and returns a #GInputStream

 * that can be used to read the response.

 *

 * @msg may not be sent until the first read call; if you need to look

 * at the status code or response headers before reading the body, you

 * can use soup_http_input_stream_send() or soup_http_input_stream_send_async()

 * to force the message to be sent and the response headers read.

 *

 * If @msg gets a non-2xx result, the first read (or send) will return

 * an error with type %SOUP_HTTP_INPUT_STREAM_HTTP_ERROR.

 *

 * Internally, #SoupHTTPInputStream is implemented using asynchronous I/O,

 * so if you are using the synchronous API (eg,

 * g_input_stream_read()), you should create a new #GMainContext and

 * set it as the %SOUP_SESSION_ASYNC_CONTEXT property on @session. (If

 * you don't, then synchronous #GInputStream calls will cause the main

 * loop to be run recursively.) The async #GInputStream API works fine

 * with %SOUP_SESSION_ASYNC_CONTEXT either set or unset.

 *

 * Returns: a new #GInputStream.

 **/

SoupHTTPInputStream *

soup_http_input_stream_new (SoupSession *session, SoupMessage *msg)

{

	SoupHTTPInputStream *stream;

	SoupHTTPInputStreamPrivate *priv;

	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);

	stream = g_object_new (SOUP_TYPE_HTTP_INPUT_STREAM, NULL);

	priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	priv->session = g_object_ref (session);

	priv->async_context = soup_session_get_async_context (session);

	priv->msg = g_object_ref (msg);

	g_signal_connect (msg, "got_headers",

			  G_CALLBACK (soup_http_input_stream_got_headers), stream);

	g_signal_connect (msg, "got_chunk",

			  G_CALLBACK (soup_http_input_stream_got_chunk), stream);

	g_signal_connect (msg, "finished",

			  G_CALLBACK (soup_http_input_stream_finished), stream);

	soup_http_input_stream_queue_message (stream);

	return stream;

}

static void

soup_http_input_stream_got_headers (SoupMessage *msg, gpointer stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	/* If the status is unsuccessful, we just ignore the signal and let

	 * libsoup keep going (eventually either it will requeue the request

	 * (after handling authentication/redirection), or else the

	 * "finished" handler will run).

	 */

	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))

		return;

	priv->got_headers = TRUE;

	if (!priv->caller_buffer) {

		/* Not ready to read the body yet */

		soup_session_pause_message (priv->session, msg);

	}

	if (priv->got_headers_cb)

		priv->got_headers_cb (stream);

}

static void

soup_http_input_stream_got_chunk (SoupMessage *msg, SoupBuffer *chunk_buffer,

				  gpointer stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	const gchar *chunk = chunk_buffer->data;

	gsize chunk_size = chunk_buffer->length;

	/* We only pay attention to the chunk if it's part of a successful

	 * response.

	 */

	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))

		return;

	/* Sanity check */

	if (priv->caller_bufsize == 0 || priv->leftover_bufsize != 0)

		g_warning ("soup_http_input_stream_got_chunk called again before previous chunk was processed");

	/* Copy what we can into priv->caller_buffer */

	if (priv->caller_bufsize - priv->caller_nread > 0) {

		gsize nread = MIN (chunk_size, priv->caller_bufsize - priv->caller_nread);

		memcpy (priv->caller_buffer + priv->caller_nread, chunk, nread);

		priv->caller_nread += nread;

		priv->offset += nread;

		chunk += nread;

		chunk_size -= nread;

	}

	if (chunk_size > 0) {

		/* Copy the rest into priv->leftover_buffer. If

		 * there's already some data there, realloc and

		 * append. Otherwise just copy.

		 */

		if (priv->leftover_bufsize) {

			priv->leftover_buffer = g_realloc (priv->leftover_buffer,

							   priv->leftover_bufsize + chunk_size);

			memcpy (priv->leftover_buffer + priv->leftover_bufsize,

				chunk, chunk_size);

			priv->leftover_bufsize += chunk_size;

		} else {

			priv->leftover_bufsize = chunk_size;

			priv->leftover_buffer = g_memdup (chunk, chunk_size);

			priv->leftover_offset = 0;

		}

	}

	soup_session_pause_message (priv->session, msg);

	if (priv->got_chunk_cb)

		priv->got_chunk_cb (stream);

}

static void

soup_http_input_stream_finished (SoupMessage *msg, gpointer stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	priv->finished = TRUE;

	if (priv->finished_cb)

		priv->finished_cb (stream);

}

static gboolean

soup_http_input_stream_cancelled (GIOChannel *chan, GIOCondition condition,

				  gpointer stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	priv->cancel_watch = NULL;

	soup_session_pause_message (priv->session, priv->msg);

	if (priv->cancelled_cb)

		priv->cancelled_cb (stream);

	return FALSE;

}

static void

soup_http_input_stream_prepare_for_io (GInputStream *stream,

				       GCancellable *cancellable,

				       guchar       *buffer,

				       gsize count)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	int cancel_fd;

	priv->cancellable = cancellable;

	cancel_fd = g_cancellable_get_fd (cancellable);

	if (cancel_fd != -1) {

		GIOChannel *chan = g_io_channel_unix_new (cancel_fd);

		priv->cancel_watch = soup_add_io_watch (priv->async_context, chan,

							G_IO_IN | G_IO_ERR | G_IO_HUP,

							soup_http_input_stream_cancelled,

							stream);

		g_io_channel_unref (chan);

	}

	priv->caller_buffer = buffer;

	priv->caller_bufsize = count;

	priv->caller_nread = 0;

	if (priv->got_headers)

		soup_session_unpause_message (priv->session, priv->msg);

}

static void

soup_http_input_stream_done_io (GInputStream *stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	if (priv->cancel_watch) {

		g_source_destroy (priv->cancel_watch);

		priv->cancel_watch = NULL;

		g_cancellable_release_fd (priv->cancellable);

	}

	priv->cancellable = NULL;

	priv->caller_buffer = NULL;

	priv->caller_bufsize = 0;

}

static gboolean

set_error_if_http_failed (SoupMessage *msg, GError **error)

{

	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

		g_set_error_literal (error, SOUP_HTTP_ERROR,

				     msg->status_code, msg->reason_phrase);

		return TRUE;

	}

	return FALSE;

}

static gsize

read_from_leftover (SoupHTTPInputStreamPrivate *priv,

		    gpointer buffer, gsize bufsize)

{

	gsize nread;

	if (priv->leftover_bufsize - priv->leftover_offset <= bufsize) {

		nread = priv->leftover_bufsize - priv->leftover_offset;

		memcpy (buffer, priv->leftover_buffer + priv->leftover_offset, nread);

		g_free (priv->leftover_buffer);

		priv->leftover_buffer = NULL;

		priv->leftover_bufsize = priv->leftover_offset = 0;

	} else {

		nread = bufsize;

		memcpy (buffer, priv->leftover_buffer + priv->leftover_offset, nread);

		priv->leftover_offset += nread;

	}

	priv->offset += nread;

	return nread;

}

/* This does the work of soup_http_input_stream_send(), assuming that the

 * GInputStream pending flag has already been set. It is also used by

 * soup_http_input_stream_send_async() in some circumstances.

 */

static gboolean

soup_http_input_stream_send_internal (GInputStream  *stream,

				      GCancellable  *cancellable,

				      GError       **error)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	soup_http_input_stream_prepare_for_io (stream, cancellable, NULL, 0);

	while (!priv->finished && !priv->got_headers &&

	       !g_cancellable_is_cancelled (cancellable))

		g_main_context_iteration (priv->async_context, TRUE);

	soup_http_input_stream_done_io (stream);

	if (g_cancellable_set_error_if_cancelled (cancellable, error))

		return FALSE;

	else if (set_error_if_http_failed (priv->msg, error))

		return FALSE;

	return TRUE;

}

static void

send_sync_finished (GInputStream *stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	GError *error = NULL;

	if (!g_cancellable_set_error_if_cancelled (priv->cancellable, &error))

		set_error_if_http_failed (priv->msg, &error);

	priv->got_headers_cb = NULL;

	priv->finished_cb = NULL;

	/* Wake up the main context iteration */

	g_source_attach (g_idle_source_new (), NULL);

}

/**

 * soup_http_input_stream_send:

 * @httpstream: a #SoupHTTPInputStream

 * @cancellable: optional #GCancellable object, %NULL to ignore.

 * @error: location to store the error occuring, or %NULL to ignore

 *

 * Synchronously sends the HTTP request associated with @stream, and

 * reads the response headers. Call this after soup_http_input_stream_new()

 * and before the first g_input_stream_read() if you want to check the

 * HTTP status code before you start reading.

 *

 * Return value: %TRUE if msg has a successful (2xx) status, %FALSE if

 * not.

 **/

gboolean

soup_http_input_stream_send (SoupHTTPInputStream  *httpstream,

			     GCancellable         *cancellable,

			     GError              **error)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (httpstream);

	GInputStream *istream = (GInputStream *)httpstream;

	gboolean result;

	g_return_val_if_fail (SOUP_IS_HTTP_INPUT_STREAM (httpstream), FALSE);

	if (!g_input_stream_set_pending (istream, error))

		return FALSE;

	priv->got_headers_cb = send_sync_finished;

	priv->finished_cb = send_sync_finished;

	result = soup_http_input_stream_send_internal (istream, cancellable, error);

	g_input_stream_clear_pending (istream);

	return result;

}

static gssize

soup_http_input_stream_read (GInputStream *stream,

			     void         *buffer,

			     gsize count,

			     GCancellable *cancellable,

			     GError      **error)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	if (priv->finished)

		return 0;

	/* If there is data leftover from a previous read, return it. */

	if (priv->leftover_bufsize)

		return read_from_leftover (priv, buffer, count);

	/* No leftover data, accept one chunk from the network */

	soup_http_input_stream_prepare_for_io (stream, cancellable, buffer, count);

	while (!priv->finished && priv->caller_nread == 0 &&

	       !g_cancellable_is_cancelled (cancellable))

		g_main_context_iteration (priv->async_context, TRUE);

	soup_http_input_stream_done_io (stream);

	if (priv->caller_nread > 0)

		return priv->caller_nread;

	if (g_cancellable_set_error_if_cancelled (cancellable, error))

		return -1;

	else if (set_error_if_http_failed (priv->msg, error))

		return -1;

	else

		return 0;

}

static gboolean

soup_http_input_stream_close (GInputStream *stream,

			      GCancellable *cancellable,

			      GError      **error)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	if (!priv->finished)

		soup_session_cancel_message (priv->session, priv->msg, SOUP_STATUS_CANCELLED);

	return TRUE;

}

static void

wrapper_callback (GObject *source_object, GAsyncResult *res,

		  gpointer user_data)

{

	GInputStream *stream = G_INPUT_STREAM (source_object);

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	g_input_stream_clear_pending (stream);

	if (priv->outstanding_callback)

		(*priv->outstanding_callback)(source_object, res, user_data);

	priv->outstanding_callback = NULL;

	g_object_unref (stream);

}

static void

send_async_thread (GSimpleAsyncResult *res,

		   GObject *object,

		   GCancellable *cancellable)

{

	GError *error = NULL;

	gboolean success;

	success = soup_http_input_stream_send_internal (G_INPUT_STREAM (object),

							cancellable, &error);

	g_simple_async_result_set_op_res_gboolean (res, success);

	if (error) {

		g_simple_async_result_set_from_error (res, error);

		g_error_free (error);

	}

}

static void

soup_http_input_stream_send_async_in_thread (GInputStream        *stream,

					     int io_priority,

					     GCancellable        *cancellable,

					     GAsyncReadyCallback callback,

					     gpointer user_data)

{

	GSimpleAsyncResult *res;

	res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data,

					 soup_http_input_stream_send_async_in_thread);

	g_simple_async_result_run_in_thread (res, send_async_thread,

					     io_priority, cancellable);

	g_object_unref (res);

}

static void

send_async_finished (GInputStream *stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	GSimpleAsyncResult *result;

	GError *error = NULL;

	if (!g_cancellable_set_error_if_cancelled (priv->cancellable, &error))

		set_error_if_http_failed (priv->msg, &error);

	priv->got_headers_cb = NULL;

	priv->finished_cb = NULL;

	soup_http_input_stream_done_io (stream);

	result = priv->result;

	priv->result = NULL;

	g_simple_async_result_set_op_res_gboolean (result, error == NULL);

	if (error) {

		g_simple_async_result_set_from_error (result, error);

		g_error_free (error);

	}

	g_simple_async_result_complete (result);

}

static void

soup_http_input_stream_send_async_internal (GInputStream        *stream,

					    int io_priority,

					    GCancellable        *cancellable,

					    GAsyncReadyCallback callback,

					    gpointer user_data)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	g_object_ref (stream);

	priv->outstanding_callback = callback;

	/* If the session uses the default GMainContext, then we can do

	 * async I/O directly. But if it has its own main context, it's

	 * easier to just run it in another thread.

	 */

	if (soup_session_get_async_context (priv->session)) {

		soup_http_input_stream_send_async_in_thread (stream, io_priority, cancellable,

							     wrapper_callback, user_data);

		return;

	}

	priv->got_headers_cb = send_async_finished;

	priv->finished_cb = send_async_finished;

	soup_http_input_stream_prepare_for_io (stream, cancellable, NULL, 0);

	priv->result = g_simple_async_result_new (G_OBJECT (stream),

						  wrapper_callback, user_data,

						  soup_http_input_stream_send_async);

}

/**

 * soup_http_input_stream_send_async:

 * @httpstream: a #SoupHTTPInputStream

 * @io_priority: the io priority of the request.

 * @cancellable: optional #GCancellable object, %NULL to ignore.

 * @callback: callback to call when the request is satisfied

 * @user_data: the data to pass to callback function

 *

 * Asynchronously sends the HTTP request associated with @stream, and

 * reads the response headers. Call this after soup_http_input_stream_new()

 * and before the first g_input_stream_read_async() if you want to

 * check the HTTP status code before you start reading.

 **/

void

soup_http_input_stream_send_async (SoupHTTPInputStream *httpstream,

				   int io_priority,

				   GCancellable        *cancellable,

				   GAsyncReadyCallback callback,

				   gpointer user_data)

{

	GInputStream *istream = (GInputStream *)httpstream;

	GError *error = NULL;

	g_return_if_fail (SOUP_IS_HTTP_INPUT_STREAM (httpstream));

	if (!g_input_stream_set_pending (istream, &error)) {

		g_simple_async_report_gerror_in_idle (G_OBJECT (httpstream),

						      callback,

						      user_data,

						      error);

		g_error_free (error);

		return;

	}

	soup_http_input_stream_send_async_internal (istream, io_priority, cancellable,

						    callback, user_data);

}

/**

 * soup_http_input_stream_send_finish:

 * @httpstream: a #SoupHTTPInputStream

 * @result: a #GAsyncResult.

 * @error: a #GError location to store the error occuring, or %NULL to

 * ignore.

 *

 * Finishes a soup_http_input_stream_send_async() operation.

 *

 * Return value: %TRUE if the message was sent successfully and

 * received a successful status code, %FALSE if not.

 **/

gboolean

soup_http_input_stream_send_finish (SoupHTTPInputStream  *httpstream,

				    GAsyncResult         *result,

				    GError              **error)

{

	GSimpleAsyncResult *simple;

	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);

	simple = G_SIMPLE_ASYNC_RESULT (result);

	g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_http_input_stream_send_async, FALSE);

	if (g_simple_async_result_propagate_error (simple, error))

		return FALSE;

	return g_simple_async_result_get_op_res_gboolean (simple);

}

static void

read_async_done (GInputStream *stream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	GSimpleAsyncResult *result;

	GError *error = NULL;

	result = priv->result;

	priv->result = NULL;

	if (g_cancellable_set_error_if_cancelled (priv->cancellable, &error) ||

	    set_error_if_http_failed (priv->msg, &error)) {

		g_simple_async_result_set_from_error (result, error);

		g_error_free (error);

	} else

		g_simple_async_result_set_op_res_gssize (result, priv->caller_nread);

	priv->got_chunk_cb = NULL;

	priv->finished_cb = NULL;

	priv->cancelled_cb = NULL;

	soup_http_input_stream_done_io (stream);

	g_simple_async_result_complete (result);

	g_object_unref (result);

}

static void

soup_http_input_stream_read_async (GInputStream        *stream,

				   void                *buffer,

				   gsize count,

				   int io_priority,

				   GCancellable        *cancellable,

				   GAsyncReadyCallback callback,

				   gpointer user_data)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (stream);

	GSimpleAsyncResult *result;

	/* If the session uses the default GMainContext, then we can do

	 * async I/O directly. But if it has its own main context, we fall

	 * back to the async-via-sync-in-another-thread implementation.

	 */

	if (soup_session_get_async_context (priv->session)) {

		G_INPUT_STREAM_CLASS (soup_http_input_stream_parent_class)->

		read_async (stream, buffer, count, io_priority,

			    cancellable, callback, user_data);

		return;

	}

	result = g_simple_async_result_new (G_OBJECT (stream),

					    callback, user_data,

					    soup_http_input_stream_read_async);

	if (priv->finished) {

		g_simple_async_result_set_op_res_gssize (result, 0);

		g_simple_async_result_complete_in_idle (result);

		g_object_unref (result);

		return;

	}

	if (priv->leftover_bufsize) {

		gsize nread = read_from_leftover (priv, buffer, count);

		g_simple_async_result_set_op_res_gssize (result, nread);

		g_simple_async_result_complete_in_idle (result);

		g_object_unref (result);

		return;

	}

	priv->result = result;

	priv->got_chunk_cb = read_async_done;

	priv->finished_cb = read_async_done;

	priv->cancelled_cb = read_async_done;

	soup_http_input_stream_prepare_for_io (stream, cancellable, buffer, count);

}

static gssize

soup_http_input_stream_read_finish (GInputStream  *stream,

				    GAsyncResult  *result,

				    GError       **error)

{

	GSimpleAsyncResult *simple;

	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), -1);

	simple = G_SIMPLE_ASYNC_RESULT (result);

	g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_http_input_stream_read_async, -1);

	return g_simple_async_result_get_op_res_gssize (simple);

}

static void

soup_http_input_stream_close_async (GInputStream       *stream,

				    int io_priority,

				    GCancellable       *cancellable,

				    GAsyncReadyCallback callback,

				    gpointer user_data)

{

	GSimpleAsyncResult *result;

	gboolean success;

	GError *error = NULL;

	result = g_simple_async_result_new (G_OBJECT (stream),

					    callback, user_data,

					    soup_http_input_stream_close_async);

	success = soup_http_input_stream_close (stream, cancellable, &error);

	g_simple_async_result_set_op_res_gboolean (result, success);

	if (error) {

		g_simple_async_result_set_from_error (result, error);

		g_error_free (error);

	}

	g_simple_async_result_complete_in_idle (result);

	g_object_unref (result);

}

static gboolean

soup_http_input_stream_close_finish (GInputStream  *stream,

				     GAsyncResult  *result,

				     GError       **error)

{

	/* Failures handled in generic close_finish code */

	return TRUE;

}

static goffset

soup_http_input_stream_tell (GSeekable *seekable)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (seekable);

	return priv->offset;

}

static gboolean

soup_http_input_stream_can_seek (GSeekable *seekable)

{

	return TRUE;

}

extern void soup_message_io_cleanup (SoupMessage *msg);

static gboolean

soup_http_input_stream_seek (GSeekable     *seekable,

			     goffset offset,

			     GSeekType type,

			     GCancellable  *cancellable,

			     GError       **error)

{

	GInputStream *stream = G_INPUT_STREAM (seekable);

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (seekable);

	char *range;

	if (type == G_SEEK_END) {

		/* FIXME: we could send "bytes=-offset", but unless we

		 * know the Content-Length, we wouldn't be able to

		 * answer a tell() properly. We could find the

		 * Content-Length by doing a HEAD...

		 */

		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,

				     "G_SEEK_END not currently supported");

		return FALSE;

	}

	if (!g_input_stream_set_pending (stream, error))

		return FALSE;

	soup_session_cancel_message (priv->session, priv->msg, SOUP_STATUS_CANCELLED);

	soup_message_io_cleanup (priv->msg);

	switch (type) {

		case G_SEEK_CUR:

			offset += priv->offset;

		/* fall through */

		case G_SEEK_SET:

			range = g_strdup_printf ("bytes=%" G_GUINT64_FORMAT "-", (guint64)offset);

			priv->offset = offset;

			break;

		case G_SEEK_END:

			range = NULL; /* keep compilers happy */

			g_return_val_if_reached (FALSE);

			break;

		default:

			g_return_val_if_reached (FALSE);

	}

	soup_message_headers_remove (priv->msg->request_headers, "Range");

	soup_message_headers_append (priv->msg->request_headers, "Range", range);

	g_free (range);

	soup_http_input_stream_queue_message (SOUP_HTTP_INPUT_STREAM (stream));

	g_input_stream_clear_pending (stream);

	return TRUE;

}

static gboolean

soup_http_input_stream_can_truncate (GSeekable *seekable)

{

	return FALSE;

}

static gboolean

soup_http_input_stream_truncate (GSeekable     *seekable,

				 goffset offset,

				 GCancellable  *cancellable,

				 GError       **error)

{

	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,

			     "Truncate not allowed on input stream");

	return FALSE;

}

SoupMessage *

soup_http_input_stream_get_message (SoupHTTPInputStream *httpstream)

{

	SoupHTTPInputStreamPrivate *priv = SOUP_HTTP_INPUT_STREAM_GET_PRIVATE (httpstream);

	return priv->msg ? g_object_ref (priv->msg) : NULL;

}

/*

 * Copyright (C) 2006, 2007, 2009 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * 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 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, write to the

 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifndef __SOUP_HTTP_INPUT_STREAM_H__

#define __SOUP_HTTP_INPUT_STREAM_H__

#include <gio/gio.h>

#include <libsoup/soup-types.h>

G_BEGIN_DECLS

#define SOUP_TYPE_HTTP_INPUT_STREAM         (soup_http_input_stream_get_type ())

#define SOUP_HTTP_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), SOUP_TYPE_HTTP_INPUT_STREAM, SoupHTTPInputStream))

#define SOUP_HTTP_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), SOUP_TYPE_HTTP_INPUT_STREAM, SoupHTTPInputStreamClass))

#define SOUP_IS_HTTP_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), SOUP_TYPE_HTTP_INPUT_STREAM))

#define SOUP_IS_HTTP_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), SOUP_TYPE_HTTP_INPUT_STREAM))

#define SOUP_HTTP_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), SOUP_TYPE_HTTP_INPUT_STREAM, SoupHTTPInputStreamClass))

typedef struct SoupHTTPInputStream SoupHTTPInputStream;

typedef struct SoupHTTPInputStreamClass SoupHTTPInputStreamClass;

struct SoupHTTPInputStream {

	GInputStream parent;

};

struct SoupHTTPInputStreamClass {

	GInputStreamClass parent_class;

	/* Padding for future expansion */

	void (*_g_reserved1)(void);

	void (*_g_reserved2)(void);

	void (*_g_reserved3)(void);

	void (*_g_reserved4)(void);

	void (*_g_reserved5)(void);

};

GType soup_http_input_stream_get_type (void) G_GNUC_CONST;

SoupHTTPInputStream *soup_http_input_stream_new (SoupSession         *session,

						 SoupMessage         *msg);

gboolean             soup_http_input_stream_send (SoupHTTPInputStream *httpstream,

						  GCancellable        *cancellable,

						  GError             **error);

void                 soup_http_input_stream_send_async (SoupHTTPInputStream *httpstream,

							int io_priority,

							GCancellable        *cancellable,

							GAsyncReadyCallback callback,

							gpointer user_data);

gboolean             soup_http_input_stream_send_finish (SoupHTTPInputStream *httpstream,

							 GAsyncResult        *result,

							 GError             **error);

SoupMessage         *soup_http_input_stream_get_message (SoupHTTPInputStream *httpstream);

G_END_DECLS

#endif /* __SOUP_HTTP_INPUT_STREAM_H__ */

/*

 * soup-request-data.c: data: URI request object

 *

 * Copyright (C) 2009 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "soup-request-data.h"

#include "soup-requester.h"

#include <libsoup/soup.h>

#include <glib/gi18n.h>

G_DEFINE_TYPE (SoupRequestData, soup_request_data, SOUP_TYPE_REQUEST)

struct _SoupRequestDataPrivate {

	gsize content_length;

	char *content_type;

};

static void

soup_request_data_init (SoupRequestData *data)

{

	data->priv = G_TYPE_INSTANCE_GET_PRIVATE (data, SOUP_TYPE_REQUEST_DATA, SoupRequestDataPrivate);

}

static void

soup_request_data_finalize (GObject *object)

{

	SoupRequestData *data = SOUP_REQUEST_DATA (object);

	g_free (data->priv->content_type);

	G_OBJECT_CLASS (soup_request_data_parent_class)->finalize (object);

}

static gboolean

soup_request_data_check_uri (SoupRequest  *request,

			     SoupURI      *uri,

			     GError      **error)

{

	return uri->host == NULL;

}

#define XDIGIT(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - 'A' + 10)

#define HEXCHAR(s) ((XDIGIT (s[1]) << 4) + XDIGIT (s[2]))

char *

uri_decoded_copy (const char *part, int length, gboolean fixup)

{

	unsigned char *s, *d;

	char *decoded = g_strndup (part, length);

	s = d = (unsigned char *)decoded;

	do {

		if (*s == '%') {

			if (!g_ascii_isxdigit (s[1]) ||

			    !g_ascii_isxdigit (s[2])) {

				if (!fixup) {

					g_free (decoded);

					return NULL;

				}

				*d++ = *s;

				continue;

			}

			*d++ = HEXCHAR (s);

			s += 2;

		} else

			*d++ = *s;

	} while (*s++);

	return decoded;

}

static GInputStream *

soup_request_data_send (SoupRequest   *request,

			GCancellable  *cancellable,

			GError       **error)

{

	SoupRequestData *data = SOUP_REQUEST_DATA (request);

	SoupURI *uri = soup_request_get_uri (request);

	GInputStream *memstream;

	const char *comma, *semi, *start, *end;

	gboolean base64 = FALSE;

	gchar *uristr = soup_uri_to_string (uri, FALSE);

	comma = strchr (uristr, ',');

	if (comma && comma != uristr) {

		/* Deal with MIME type / params */

		semi = memchr (uristr, ';', comma - uristr);

		end = semi ? semi : comma;

		if (end != uristr)

			data->priv->content_type = uri_decoded_copy (uristr, end - uristr, TRUE);

		if (semi && !g_ascii_strncasecmp (semi, ";base64", MAX (comma - semi, strlen (";base64"))))

			base64 = TRUE;

	}

	memstream = g_memory_input_stream_new ();

	start = comma ? comma + 1 : uristr;

	if (*start) {

		guchar *buf;

		if (base64) {

			int inlen, state = 0;

			guint save = 0;

			char *unescaped;

			if (strchr (start, '%')) {

				start = unescaped = uri_decoded_copy (start, strlen (start), TRUE);

				if (!unescaped)

					goto fail;

			} else

				unescaped = NULL;

			inlen = strlen (start);

			buf = g_malloc (inlen * 3 / 4);

			data->priv->content_length =

				g_base64_decode_step (start, inlen, buf,

						      &state, &save);

			g_free (unescaped);

			if (state != 0) {

				g_free (buf);

				goto fail;

			}

		} else {

			/* Cannot use g_uri_unescape_string nor

			   soup_uri_decode because we don't want to

			   fail for things like "%3E%%3C" -> ">%<" */

			buf = (guchar *)uri_decoded_copy (start, strlen (start), TRUE);

			if (!buf)

				goto fail;

			data->priv->content_length = strlen ((char *)buf);

		}

		g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (memstream),

						buf, data->priv->content_length,

						g_free);

	}

	g_free (uristr);

	return memstream;

 fail:

	g_free (uristr);

	g_set_error (error, SOUP_ERROR, SOUP_ERROR_BAD_URI,

		     _ ("Unable to decode URI: %s"), start);

	g_object_unref (memstream);

	return NULL;

}

static goffset

soup_request_data_get_content_length (SoupRequest *request)

{

	SoupRequestData *data = SOUP_REQUEST_DATA (request);

	return data->priv->content_length;

}

static const char *

soup_request_data_get_content_type (SoupRequest *request)

{

	SoupRequestData *data = SOUP_REQUEST_DATA (request);

	return data->priv->content_type;

}

static void

soup_request_data_class_init (SoupRequestDataClass *request_data_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (request_data_class);

	SoupRequestClass *request_class =

		SOUP_REQUEST_CLASS (request_data_class);

	g_type_class_add_private (request_data_class, sizeof (SoupRequestDataPrivate));

	object_class->finalize = soup_request_data_finalize;

	request_class->check_uri = soup_request_data_check_uri;

	request_class->send = soup_request_data_send;

	request_class->get_content_length = soup_request_data_get_content_length;

	request_class->get_content_type = soup_request_data_get_content_type;

}

/*

 * Copyright (C) 2009 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifndef SOUP_REQUEST_DATA_H

#define SOUP_REQUEST_DATA_H 1

#include "soup-request.h"

G_BEGIN_DECLS

#define SOUP_TYPE_REQUEST_DATA            (soup_request_data_get_type ())

#define SOUP_REQUEST_DATA(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_REQUEST_DATA, SoupRequestData))

#define SOUP_REQUEST_DATA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_REQUEST_DATA, SoupRequestDataClass))

#define SOUP_IS_REQUEST_DATA(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_REQUEST_DATA))

#define SOUP_IS_REQUEST_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_REQUEST_DATA))

#define SOUP_REQUEST_DATA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_REQUEST_DATA, SoupRequestDataClass))

typedef struct _SoupRequestDataPrivate SoupRequestDataPrivate;

typedef struct {

	SoupRequest parent;

	SoupRequestDataPrivate *priv;

} SoupRequestData;

typedef struct {

	SoupRequestClass parent;

} SoupRequestDataClass;

GType soup_request_data_get_type (void);

G_END_DECLS

#endif /* SOUP_REQUEST_DATA_H */

/*

 * soup-request-file.c: file: URI request object

 *

 * Copyright (C) 2009 Red Hat, Inc.

 * Copyright (C) 2010 Igalia, S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "soup-request-file.h"

#include "soup-directory-input-stream.h"

#include "soup-requester.h"

#include <glib/gi18n.h>

G_DEFINE_TYPE (SoupRequestFile, soup_request_file, SOUP_TYPE_REQUEST)

struct _SoupRequestFilePrivate {

	GFile *gfile;

	char *mime_type;

	goffset size;

};

GFile *

soup_request_file_get_file (SoupRequestFile *file)

{

	return g_object_ref (file->priv->gfile);

}

static void

soup_request_file_init (SoupRequestFile *file)

{

	file->priv = G_TYPE_INSTANCE_GET_PRIVATE (file, SOUP_TYPE_REQUEST_FILE, SoupRequestFilePrivate);

	file->priv->size = -1;

}

static void

soup_request_file_finalize (GObject *object)

{

	SoupRequestFile *file = SOUP_REQUEST_FILE (object);

	if (file->priv->gfile)

		g_object_unref (file->priv->gfile);

	g_free (file->priv->mime_type);

	G_OBJECT_CLASS (soup_request_file_parent_class)->finalize (object);

}

static gboolean

soup_request_file_check_uri (SoupRequest  *request,

			     SoupURI      *uri,

			     GError      **error)

{

	/* "file:/foo" is not valid */

	if (!uri->host)

		return FALSE;

	/* but it must be "file:///..." or "file://localhost/..." */

	if (uri->scheme == SOUP_URI_SCHEME_FILE &&

	    *uri->host &&

	    g_ascii_strcasecmp (uri->host, "localhost") != 0)

		return FALSE;

	return TRUE;

}

static void

soup_request_file_ftp_main_loop_quit (GObject      *object,

				      GAsyncResult *result,

				      gpointer loop)

{

	g_main_loop_quit (loop);

}

/* This is a somewhat hacky way to get FTP to almost work. The proper way to

 * get FTP to _really_ work involves hacking GIO to have APIs to handle

 * canoncial URLs.

 */

static GFile *

soup_request_file_ensure_file_ftp (SoupURI       *uri,

				   GCancellable  *cancellable,

				   GError       **error)

{

	SoupURI *host;

	char *s;

	GFile *file, *result;

	GMount *mount;

	host = soup_uri_copy_host (uri);

	s = soup_uri_to_string (host, FALSE);

	file = g_file_new_for_uri (s);

	soup_uri_free (host);

	g_free (s);

	mount = g_file_find_enclosing_mount (file, cancellable, error);

	if (mount == NULL && g_file_supports_thread_contexts (file)) {

		GMainContext *context = g_main_context_new ();

		GMainLoop *loop = g_main_loop_new (context, FALSE);

		g_clear_error (error);

		g_main_context_push_thread_default (context);

		g_file_mount_enclosing_volume (file,

					       G_MOUNT_MOUNT_NONE,

					       NULL, /* FIXME! */

					       cancellable,

					       soup_request_file_ftp_main_loop_quit,

					       loop);

		g_main_loop_run (loop);

		g_main_context_pop_thread_default (context);

		g_main_loop_unref (loop);

		g_main_context_unref (context);

		mount = g_file_find_enclosing_mount (file, cancellable, error);

	}

	if (mount == NULL)

		return NULL;

	g_object_unref (file);

	file = g_mount_get_default_location (mount);

	g_object_unref (mount);

	s = g_strdup (uri->path);

	if (strchr (s, ';'))

		*strchr (s, ';') = 0;