zjl/new
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
new/yocto/meta-openembedded/meta-gnome/recipes-gnome/rest/files/0002-Port-to-libsoup3.patch
zjl 295e01dc7a first commit
2025-05-10 21:58:58 +08:00

1697 lines
55 KiB
Diff
Raw Permalink Blame History

From 3dc630ae5b9dc6cda1ba318de2cd654aaba7b4a2 Mon Sep 17 00:00:00 2001
From: Carlos Garcia Campos <cgarcia@igalia.com>
Date: Tue, 8 Jun 2021 17:44:04 +0200
Subject: [PATCH 2/2] Port to libsoup3
Upstream-Status: Submitted [https://gitlab.gnome.org/GNOME/librest/-/merge_requests/6]
---
configure.ac | 39 ++++-
rest-extras.pc.in | 2 +-
rest-extras/youtube-proxy.c | 110 +++++++++++---
rest.pc.in | 2 +-
rest/rest-private.h | 22 ++-
rest/rest-proxy-auth.c | 16 ++
rest/rest-proxy-call.c | 296 +++++++++++++++++++++++++++++-------
rest/rest-proxy.c | 209 ++++++++++++++++++++++---
tests/custom-serialize.c | 18 +++
tests/proxy-continuous.c | 37 ++++-
tests/proxy.c | 63 +++++++-
tests/threaded.c | 17 +++
12 files changed, 719 insertions(+), 112 deletions(-)
diff --git a/configure.ac b/configure.ac
index d586e69..75c02fe 100644
--- a/configure.ac
+++ b/configure.ac
@@ -20,12 +20,6 @@ AM_INIT_AUTOMAKE([1.11 foreign -Wno-portability no-define dist-xz])
AM_SILENT_RULES([yes])
-API_MAJOR=1
-API_MINOR=0
-AC_SUBST([API_VERSION],[$API_MAJOR.$API_MINOR])
-AC_SUBST([API_VERSION_AM],[$API_MAJOR\_$API_MINOR])
-AC_DEFINE_UNQUOTED(API_VERSION, [$API_VERSION], [API version])
-
AC_CANONICAL_HOST
AC_PROG_CC
@@ -41,7 +35,6 @@ LT_PREREQ([2.2.6])
LT_INIT([disable-static])
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.67.4)
-PKG_CHECK_MODULES(SOUP, libsoup-2.4 >= 2.42)
PKG_CHECK_MODULES(XML, libxml-2.0)
PKG_CHECK_MODULES(GTHREAD, gthread-2.0)
@@ -58,6 +51,37 @@ AC_PATH_PROG([GLIB_MKENUMS],[glib-mkenums])
localedir=${datadir}/locale
AC_SUBST(localedir)
+AC_MSG_CHECKING([for libsoup version to use])
+AC_ARG_WITH(soup,
+ [AC_HELP_STRING([--soup=2|3],
+ [version of libsoup library to use (default: 2)])],
+ [case "$withval" in
+ 2|3) ;;
+ *) AC_MSG_ERROR([invalid argument "$withval" for --with-soup]) ;;
+ esac],
+ [with_soup=2])
+AC_MSG_RESULT([$with_soup])
+
+API_MAJOR=1
+
+if test "$with_soup" = "2"; then
+ PKG_CHECK_MODULES(SOUP, libsoup-2.4 >= 2.42)
+ SOUP_API_VERSION=2.4
+ API_MINOR=0
+ AC_DEFINE([WITH_SOUP_2],[1],[Define if libsoup version used is 2])
+else
+ PKG_CHECK_MODULES(SOUP, libsoup-3.0 >= 2.99.8)
+ SOUP_API_VERSION=3.0
+ API_MINOR=1
+fi
+
+AM_CONDITIONAL([WITH_SOUP_2],[test "$with_soup" = "2"])
+AC_SUBST(SOUP_API_VERSION)
+
+AC_SUBST([API_VERSION],[$API_MAJOR.$API_MINOR])
+AC_SUBST([API_VERSION_AM],[$API_MAJOR\_$API_MINOR])
+AC_DEFINE_UNQUOTED(API_VERSION, [$API_VERSION], [API version])
+
dnl === Coverage report =======================================================
AC_PATH_PROG([GCOV], [lcov], [enable_gcov=no])
@@ -130,6 +154,7 @@ echo " LibRest $VERSION"
echo " ================"
echo ""
echo " prefix: ${prefix}"
+echo " libsoup version: ${with_soup}"
echo ""
echo " Documentation: ${enable_gtk_doc}"
echo " Introspection data: ${enable_introspection}"
diff --git a/rest-extras.pc.in b/rest-extras.pc.in
index 39f21bf..3723d6d 100644
--- a/rest-extras.pc.in
+++ b/rest-extras.pc.in
@@ -9,4 +9,4 @@ Description: RESTful web api query library
Version: @VERSION@
Libs: -L${libdir} -lrest-extras-${apiversion}
Cflags: -I${includedir}/rest-${apiversion}
-Requires: glib-2.0 libsoup-2.4 libxml-2.0
+Requires: glib-2.0 libsoup-@SOUP_API_VERSION@ libxml-2.0
diff --git a/rest-extras/youtube-proxy.c b/rest-extras/youtube-proxy.c
index be0cf08..cd598f4 100644
--- a/rest-extras/youtube-proxy.c
+++ b/rest-extras/youtube-proxy.c
@@ -246,6 +246,9 @@ typedef struct {
GObject *weak_object;
gpointer user_data;
gsize uploaded;
+#ifndef WITH_SOUP_2
+ GCancellable *cancellable;
+#endif
} YoutubeProxyUploadClosure;
static void
@@ -255,7 +258,11 @@ _upload_async_weak_notify_cb (gpointer *data,
YoutubeProxyUploadClosure *closure =
(YoutubeProxyUploadClosure *) data;
+#ifdef WITH_SOUP_2
_rest_proxy_cancel_message (REST_PROXY (closure->proxy), closure->message);
+#else
+ g_cancellable_cancel (closure->cancellable);
+#endif
}
static void
@@ -267,6 +274,9 @@ _upload_async_closure_free (YoutubeProxyUploadClosure *closure)
closure);
g_object_unref (closure->proxy);
+#ifndef WITH_SOUP_2
+ g_object_unref (closure->cancellable);
+#endif
g_slice_free (YoutubeProxyUploadClosure, closure);
}
@@ -286,6 +296,9 @@ _upload_async_closure_new (YoutubeProxy *self,
closure->message = message;
closure->weak_object = weak_object;
closure->user_data = user_data;
+#ifndef WITH_SOUP_2
+ closure->cancellable = g_cancellable_new ();
+#endif
if (weak_object != NULL)
g_object_weak_ref (weak_object,
@@ -295,41 +308,67 @@ _upload_async_closure_new (YoutubeProxy *self,
}
static void
-_upload_completed_cb (SoupSession *session,
- SoupMessage *message,
+_upload_completed_cb (SoupMessage *message,
+ GBytes *payload,
+ GError *error,
gpointer user_data)
{
YoutubeProxyUploadClosure *closure =
(YoutubeProxyUploadClosure *) user_data;
- GError *error = NULL;
+ gsize length;
+ gconstpointer data;
+ guint status_code;
+ const char *reason_phrase;
if (closure->callback == NULL)
return;
- if (message->status_code < 200 || message->status_code >= 300)
- error = g_error_new_literal (REST_PROXY_ERROR,
- message->status_code,
- message->reason_phrase);
-
- closure->callback (closure->proxy, message->response_body->data,
- message->request_body->length,
- message->request_body->length,
+#ifdef WITH_SOUP_2
+ status_code = message->status_code;
+ reason_phrase = message->reason_phrase;
+#else
+ status_code = soup_message_get_status (message);
+ reason_phrase = soup_message_get_reason_phrase (message);
+#endif
+
+ if (status_code < 200 || status_code >= 300)
+ {
+ g_clear_error (&error);
+ error = g_error_new_literal (REST_PROXY_ERROR,
+ status_code,
+ reason_phrase);
+ }
+
+ data = g_bytes_get_data (payload, &length);
+ closure->callback (closure->proxy, data, length, length,
error, closure->weak_object, closure->user_data);
+ g_bytes_unref (payload);
_upload_async_closure_free (closure);
}
static void
_message_wrote_data_cb (SoupMessage *msg,
+#ifdef WITH_SOUP_2
SoupBuffer *chunk,
+#else
+ gsize chunk_size,
+#endif
YoutubeProxyUploadClosure *closure)
{
- closure->uploaded = closure->uploaded + chunk->length;
+#ifdef WITH_SOUP_2
+ gsize chunk_size = chunk->length;
+ goffset content_length = msg->request_body->length;
+#else
+ goffset content_length = soup_message_headers_get_content_length (soup_message_get_request_headers (msg));
+#endif
+
+ closure->uploaded = closure->uploaded + chunk_size;
- if (closure->uploaded < msg->request_body->length)
+ if (closure->uploaded < content_length)
closure->callback (closure->proxy,
NULL,
- msg->request_body->length,
+ content_length,
closure->uploaded,
NULL,
closure->weak_object,
@@ -364,7 +403,12 @@ youtube_proxy_upload_async (YoutubeProxy *self,
SoupMultipart *mp;
SoupMessage *message;
SoupMessageHeaders *part_headers;
+ SoupMessageHeaders *request_headers;
+#ifdef WITH_SOUP_2
SoupBuffer *sb;
+#else
+ GBytes *sb;
+#endif
gchar *content_type;
gchar *atom_xml;
GMappedFile *map;
@@ -380,10 +424,17 @@ youtube_proxy_upload_async (YoutubeProxy *self,
atom_xml = _construct_upload_atom_xml (fields, incomplete);
+#ifdef WITH_SOUP_2
sb = soup_buffer_new_with_owner (atom_xml,
strlen(atom_xml),
atom_xml,
(GDestroyNotify) g_free);
+#else
+ sb = g_bytes_new_with_free_func (atom_xml,
+ strlen (atom_xml),
+ (GDestroyNotify) g_free,
+ atom_xml);
+#endif
part_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_MULTIPART);
@@ -393,7 +444,11 @@ youtube_proxy_upload_async (YoutubeProxy *self,
soup_multipart_append_part (mp, part_headers, sb);
+#ifdef WITH_SOUP_2
soup_buffer_free (sb);
+#else
+ g_bytes_unref (sb);
+#endif
content_type = g_content_type_guess (
filename,
@@ -401,24 +456,37 @@ youtube_proxy_upload_async (YoutubeProxy *self,
g_mapped_file_get_length (map),
NULL);
+#ifdef WITH_SOUP_2
sb = soup_buffer_new_with_owner (g_mapped_file_get_contents (map),
g_mapped_file_get_length (map),
map,
(GDestroyNotify) g_mapped_file_unref);
+#else
+ sb = g_bytes_new_with_free_func (g_mapped_file_get_contents (map),
+ g_mapped_file_get_length (map),
+ (GDestroyNotify) g_mapped_file_unref,
+ map);
+#endif
soup_message_headers_replace (part_headers, "Content-Type", content_type);
soup_multipart_append_part (mp, part_headers, sb);
+#ifdef WITH_SOUP_2
soup_buffer_free (sb);
-
soup_message_headers_free (part_headers);
-
message = soup_form_request_new_from_multipart (UPLOAD_URL, mp);
+ request_headers = message->request_headers;
+#else
+ g_bytes_unref (sb);
+ soup_message_headers_unref (part_headers);
+ message = soup_message_new_from_multipart (UPLOAD_URL, mp);
+ request_headers = soup_message_get_request_headers (message);
+#endif
soup_multipart_free (mp);
- _set_upload_headers (self, message->request_headers, filename);
+ _set_upload_headers (self, request_headers, filename);
closure = _upload_async_closure_new (self, callback, message, weak_object,
user_data);
@@ -429,7 +497,13 @@ youtube_proxy_upload_async (YoutubeProxy *self,
closure);
- _rest_proxy_queue_message (REST_PROXY (self), message, _upload_completed_cb,
+ _rest_proxy_queue_message (REST_PROXY (self), message,
+#ifdef WITH_SOUP_2
+ NULL,
+#else
+ closure->cancellable,
+#endif
+ _upload_completed_cb,
closure);
return TRUE;
diff --git a/rest.pc.in b/rest.pc.in
index 94c384b..e6bae3e 100644
--- a/rest.pc.in
+++ b/rest.pc.in
@@ -9,4 +9,4 @@ Description: RESTful web api query library
Version: @VERSION@
Libs: -L${libdir} -lrest-${apiversion}
Cflags: -I${includedir}/rest-${apiversion}
-Requires: glib-2.0 libsoup-2.4 libxml-2.0
+Requires: glib-2.0 libsoup-@SOUP_API_VERSION@ libxml-2.0
diff --git a/rest/rest-private.h b/rest/rest-private.h
index 9e91fa0..6e71322 100644
--- a/rest/rest-private.h
+++ b/rest/rest-private.h
@@ -31,6 +31,11 @@
G_BEGIN_DECLS
+typedef void (*RestMessageFinishedCallback) (SoupMessage *msg,
+ GBytes *body,
+ GError *error,
+ gpointer user_data);
+
typedef enum
{
REST_DEBUG_XML_PARSER = 1 << 0,
@@ -53,12 +58,23 @@ gboolean _rest_proxy_get_binding_required (RestProxy *proxy);
const gchar *_rest_proxy_get_bound_url (RestProxy *proxy);
void _rest_proxy_queue_message (RestProxy *proxy,
SoupMessage *message,
- SoupSessionCallback callback,
+ GCancellable *cancellable,
+ RestMessageFinishedCallback callback,
gpointer user_data);
void _rest_proxy_cancel_message (RestProxy *proxy,
SoupMessage *message);
-guint _rest_proxy_send_message (RestProxy *proxy,
- SoupMessage *message);
+GBytes *_rest_proxy_send_message (RestProxy *proxy,
+ SoupMessage *message,
+ GCancellable *cancellable,
+ GError **error);
+void _rest_proxy_send_message_async (RestProxy *proxy,
+ SoupMessage *message,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GInputStream *_rest_proxy_send_message_finish (RestProxy *proxy,
+ GAsyncResult *result,
+ GError **error);
RestXmlNode *_rest_xml_node_new (void);
void _rest_xml_node_reverse_children_siblings (RestXmlNode *node);
diff --git a/rest/rest-proxy-auth.c b/rest/rest-proxy-auth.c
index b96e443..0b2ec9f 100644
--- a/rest/rest-proxy-auth.c
+++ b/rest/rest-proxy-auth.c
@@ -29,7 +29,9 @@
struct _RestProxyAuthPrivate {
/* used to hold state during async authentication */
RestProxy *proxy;
+#ifdef WITH_SOUP_2
SoupSession *session;
+#endif
SoupMessage *message;
SoupAuth *auth;
gboolean paused;
@@ -43,7 +45,9 @@ rest_proxy_auth_dispose (GObject *object)
RestProxyAuthPrivate *priv = ((RestProxyAuth*)object)->priv;
g_clear_object (&priv->proxy);
+#ifdef WITH_SOUP_2
g_clear_object (&priv->session);
+#endif
g_clear_object (&priv->message);
g_clear_object (&priv->auth);
@@ -73,13 +77,17 @@ rest_proxy_auth_new (RestProxy *proxy,
RestProxyAuth *rest_auth;
g_return_val_if_fail (REST_IS_PROXY (proxy), NULL);
+#ifdef WITH_SOUP_2
g_return_val_if_fail (SOUP_IS_SESSION (session), NULL);
+#endif
g_return_val_if_fail (SOUP_IS_MESSAGE (message), NULL);
g_return_val_if_fail (SOUP_IS_AUTH (soup_auth), NULL);
rest_auth = REST_PROXY_AUTH (g_object_new (REST_TYPE_PROXY_AUTH, NULL));
rest_auth->priv->proxy = g_object_ref(proxy);
+#ifdef WITH_SOUP_2
rest_auth->priv->session = g_object_ref(session);
+#endif
rest_auth->priv->message = g_object_ref(message);
rest_auth->priv->auth = g_object_ref(soup_auth);
@@ -104,7 +112,9 @@ rest_proxy_auth_pause (RestProxyAuth *auth)
return;
auth->priv->paused = TRUE;
+#ifdef WITH_SOUP_2
soup_session_pause_message (auth->priv->session, auth->priv->message);
+#endif
}
/**
@@ -128,7 +138,9 @@ rest_proxy_auth_unpause (RestProxyAuth *auth)
soup_auth_authenticate (auth->priv->auth, username, password);
g_free (username);
g_free (password);
+#ifdef WITH_SOUP_2
soup_session_unpause_message (auth->priv->session, auth->priv->message);
+#endif
auth->priv->paused = FALSE;
}
@@ -146,7 +158,11 @@ rest_proxy_auth_cancel (RestProxyAuth *auth)
{
g_return_if_fail (REST_IS_PROXY_AUTH (auth));
+#ifdef WITH_SOUP_2
soup_session_cancel_message (auth->priv->session, auth->priv->message, SOUP_STATUS_CANCELLED);
+#else
+ soup_auth_cancel (auth->priv->auth);
+#endif
}
G_GNUC_INTERNAL gboolean rest_proxy_auth_is_paused (RestProxyAuth *auth)
diff --git a/rest/rest-proxy-call.c b/rest/rest-proxy-call.c
index 2ab722f..62b00da 100644
--- a/rest/rest-proxy-call.c
+++ b/rest/rest-proxy-call.c
@@ -20,12 +20,14 @@
*
*/
+#include <config.h>
#include <rest/rest-proxy.h>
#include <rest/rest-proxy-call.h>
#include <rest/rest-params.h>
#include <libsoup/soup.h>
#include "rest-private.h"
+#include "rest-proxy-auth-private.h"
#include "rest-proxy-call-private.h"
@@ -38,12 +40,15 @@ struct _RestProxyCallAsyncClosure {
};
typedef struct _RestProxyCallAsyncClosure RestProxyCallAsyncClosure;
+#define READ_BUFFER_SIZE 8192
+
struct _RestProxyCallContinuousClosure {
RestProxyCall *call;
RestProxyCallContinuousCallback callback;
GObject *weak_object;
gpointer userdata;
SoupMessage *message;
+ guchar buffer[READ_BUFFER_SIZE];
};
typedef struct _RestProxyCallContinuousClosure RestProxyCallContinuousClosure;
@@ -70,8 +75,7 @@ struct _RestProxyCallPrivate {
gchar *url;
GHashTable *response_headers;
- goffset length;
- gchar *payload;
+ GBytes *payload;
guint status_code;
gchar *status_message;
@@ -160,7 +164,7 @@ rest_proxy_call_finalize (GObject *object)
g_free (priv->method);
g_free (priv->function);
- g_free (priv->payload);
+ g_clear_pointer (&priv->payload, g_bytes_unref);
g_free (priv->status_message);
g_free (priv->url);
@@ -546,14 +550,23 @@ _populate_headers_hash_table (const gchar *name,
g_hash_table_insert (headers, g_strdup (name), g_strdup (value));
}
+#ifdef WITH_SOUP_2
/* I apologise for this macro, but it saves typing ;-) */
#define error_helper(x) g_set_error_literal(error, REST_PROXY_ERROR, x, message->reason_phrase)
+#endif
static gboolean
_handle_error_from_message (SoupMessage *message, GError **error)
{
- if (message->status_code < 100)
+ guint status_code;
+ const char *reason_phrase;
+
+#ifdef WITH_SOUP_2
+ status_code = message->status_code;
+
+ if (status_code < 100)
{
- switch (message->status_code)
+ g_clear_error (error);
+ switch (status_code)
{
case SOUP_STATUS_CANCELLED:
error_helper (REST_PROXY_ERROR_CANCELLED);
@@ -580,61 +593,84 @@ _handle_error_from_message (SoupMessage *message, GError **error)
}
return FALSE;
}
+ reason_phrase = message->reason_phrase;
+#else
+ status_code = soup_message_get_status (message);
+ reason_phrase = soup_message_get_reason_phrase (message);
+#endif
- if (message->status_code >= 200 && message->status_code < 300)
+ if (status_code >= 200 && status_code < 300)
{
return TRUE;
}
+ if (*error != NULL)
+ return FALSE;
+
/* If we are here we must be in some kind of HTTP error, lets try */
g_set_error_literal (error,
REST_PROXY_ERROR,
- message->status_code,
- message->reason_phrase);
+ status_code,
+ reason_phrase);
return FALSE;
}
static gboolean
-finish_call (RestProxyCall *call, SoupMessage *message, GError **error)
+finish_call (RestProxyCall *call, SoupMessage *message, GBytes *payload, GError **error)
{
RestProxyCallPrivate *priv = GET_PRIVATE (call);
+ SoupMessageHeaders *response_headers;
g_assert (call);
g_assert (message);
+ g_assert (payload);
+
+#ifdef WITH_SOUP_2
+ response_headers = message->response_headers;
+#else
+ response_headers = soup_message_get_response_headers (message);
+#endif
/* Convert the soup headers in to hash */
/* FIXME: Eeek..are you allowed duplicate headers? ... */
g_hash_table_remove_all (priv->response_headers);
- soup_message_headers_foreach (message->response_headers,
+ soup_message_headers_foreach (response_headers,
(SoupMessageHeadersForeachFunc)_populate_headers_hash_table,
priv->response_headers);
- priv->payload = g_memdup (message->response_body->data,
- message->response_body->length + 1);
- priv->length = message->response_body->length;
+ priv->payload = payload;
+#ifdef WITH_SOUP_2
priv->status_code = message->status_code;
priv->status_message = g_strdup (message->reason_phrase);
+#else
+ priv->status_code = soup_message_get_status (message);
+ priv->status_message = g_strdup (soup_message_get_reason_phrase (message));
+#endif
return _handle_error_from_message (message, error);
}
static void
-_continuous_call_message_completed_cb (SoupSession *session,
- SoupMessage *message,
- gpointer userdata)
+_continuous_call_message_completed (SoupMessage *message,
+ GError *error,
+ gpointer userdata)
{
RestProxyCallContinuousClosure *closure;
RestProxyCall *call;
RestProxyCallPrivate *priv;
- GError *error = NULL;
closure = (RestProxyCallContinuousClosure *)userdata;
call = closure->call;
priv = GET_PRIVATE (call);
+#ifdef WITH_SOUP_2
priv->status_code = message->status_code;
priv->status_message = g_strdup (message->reason_phrase);
+#else
+ priv->status_code = soup_message_get_status (message);
+ priv->status_message = g_strdup (soup_message_get_reason_phrase (message));
+#endif
_handle_error_from_message (message, &error);
@@ -657,6 +693,7 @@ _continuous_call_message_completed_cb (SoupSession *session,
priv->cur_call_closure = NULL;
g_object_unref (closure->call);
+ g_object_unref (message);
g_slice_free (RestProxyCallContinuousClosure, closure);
}
@@ -715,6 +752,49 @@ set_url (RestProxyCall *call)
return TRUE;
}
+#ifndef WITH_SOUP_2
+static gboolean
+authenticate (RestProxyCall *call,
+ SoupAuth *soup_auth,
+ gboolean retrying,
+ SoupMessage *message)
+{
+ RestProxyCallPrivate *priv = GET_PRIVATE (call);
+ RestProxyAuth *rest_auth;
+ gboolean try_auth;
+
+ rest_auth = rest_proxy_auth_new (priv->proxy, NULL, message, soup_auth);
+ g_signal_emit_by_name (priv->proxy, "authenticate", rest_auth, retrying, &try_auth);
+ if (try_auth && !rest_proxy_auth_is_paused (rest_auth)) {
+ char *username, *password;
+
+ g_object_get (priv->proxy, "username", &username, "password", &password, NULL);
+ soup_auth_authenticate (soup_auth, username, password);
+ g_free (username);
+ g_free (password);
+ }
+ g_object_unref (rest_auth);
+
+ return try_auth;
+}
+
+static gboolean
+accept_certificate (RestProxyCall *call,
+ GTlsCertificate *tls_certificate,
+ GTlsCertificateFlags *tls_errors,
+ SoupMessage *message)
+{
+ RestProxyCallPrivate *priv = GET_PRIVATE (call);
+ gboolean ssl_strict;
+
+ if (tls_errors == 0)
+ return TRUE;
+
+ g_object_get (priv->proxy, "ssl-strict", &ssl_strict, NULL);
+ return !ssl_strict;
+}
+#endif
+
static SoupMessage *
prepare_message (RestProxyCall *call, GError **error_out)
{
@@ -722,6 +802,7 @@ prepare_message (RestProxyCall *call, GError **error_out)
RestProxyCallClass *call_class;
const gchar *user_agent;
SoupMessage *message;
+ SoupMessageHeaders *request_headers;
GError *error = NULL;
call_class = REST_PROXY_CALL_GET_CLASS (call);
@@ -748,6 +829,9 @@ prepare_message (RestProxyCall *call, GError **error_out)
gchar *content;
gchar *content_type;
gsize content_len;
+#ifndef WITH_SOUP_2
+ GBytes *body;
+#endif
if (!call_class->serialize_params (call, &content_type,
&content, &content_len, &error))
@@ -780,8 +864,14 @@ prepare_message (RestProxyCall *call, GError **error_out)
"Could not parse URI");
return NULL;
}
+#ifdef WITH_SOUP_2
soup_message_set_request (message, content_type,
SOUP_MEMORY_TAKE, content, content_len);
+#else
+ body = g_bytes_new_take (content, content_len);
+ soup_message_set_request_body_from_bytes (message, content_type, body);
+ g_bytes_unref (body);
+#endif
g_free (content_type);
} else if (rest_params_are_strings (priv->params)) {
@@ -798,9 +888,15 @@ prepare_message (RestProxyCall *call, GError **error_out)
hash = rest_params_as_string_hash_table (priv->params);
+#ifdef WITH_SOUP_2
message = soup_form_request_new_from_hash (priv->method,
priv->url,
hash);
+#else
+ message = soup_message_new_from_encoded_form (priv->method,
+ priv->url,
+ soup_form_encode_hash (hash));
+#endif
g_hash_table_unref (hash);
@@ -827,19 +923,28 @@ prepare_message (RestProxyCall *call, GError **error_out)
if (rest_param_is_string (param)) {
soup_multipart_append_form_string (mp, name, rest_param_get_content (param));
} else {
- SoupBuffer *sb;
-
- sb = soup_buffer_new_with_owner (rest_param_get_content (param),
- rest_param_get_content_length (param),
- rest_param_ref (param),
- (GDestroyNotify)rest_param_unref);
+#ifdef WITH_SOUP_2
+ SoupBuffer *sb = soup_buffer_new_with_owner (rest_param_get_content (param),
+ rest_param_get_content_length (param),
+ rest_param_ref (param),
+ (GDestroyNotify)rest_param_unref);
+#else
+ GBytes *sb = g_bytes_new_with_free_func (rest_param_get_content (param),
+ rest_param_get_content_length (param),
+ (GDestroyNotify)rest_param_unref,
+ rest_param_ref (param));
+#endif
soup_multipart_append_form_file (mp, name,
rest_param_get_file_name (param),
rest_param_get_content_type (param),
sb);
+#ifdef WITH_SOUP_2
soup_buffer_free (sb);
+#else
+ g_bytes_unref (sb);
+#endif
}
}
@@ -853,19 +958,36 @@ prepare_message (RestProxyCall *call, GError **error_out)
return NULL;
}
+#ifdef WITH_SOUP_2
message = soup_form_request_new_from_multipart (priv->url, mp);
+#else
+ message = soup_message_new_from_multipart (priv->url, mp);
+#endif
soup_multipart_free (mp);
}
+#ifdef WITH_SOUP_2
+ request_headers = message->request_headers;
+#else
+ request_headers = soup_message_get_request_headers (message);
+ g_signal_connect_swapped (message, "authenticate",
+ G_CALLBACK (authenticate),
+ call);
+ g_signal_connect_swapped (message, "accept-certificate",
+ G_CALLBACK (accept_certificate),
+ call);
+#endif
+
+
/* Set the user agent, if one was set in the proxy */
user_agent = rest_proxy_get_user_agent (priv->proxy);
if (user_agent) {
- soup_message_headers_append (message->request_headers, "User-Agent", user_agent);
+ soup_message_headers_append (request_headers, "User-Agent", user_agent);
}
/* Set the headers */
- g_hash_table_foreach (priv->headers, set_header, message->request_headers);
+ g_hash_table_foreach (priv->headers, set_header, request_headers);
return message;
}
@@ -878,17 +1000,17 @@ _call_message_call_cancelled_cb (GCancellable *cancellable,
}
static void
-_call_message_call_completed_cb (SoupSession *session,
- SoupMessage *message,
+_call_message_call_completed_cb (SoupMessage *message,
+ GBytes *payload,
+ GError *error,
gpointer user_data)
{
GTask *task = user_data;
RestProxyCall *call;
- GError *error = NULL;
call = REST_PROXY_CALL (g_task_get_source_object (task));
- finish_call (call, message, &error);
+ finish_call (call, message, payload, &error);
if (error != NULL)
g_task_return_error (task, error);
@@ -938,6 +1060,7 @@ rest_proxy_call_invoke_async (RestProxyCall *call,
_rest_proxy_queue_message (priv->proxy,
message,
+ priv->cancellable,
_call_message_call_completed_cb,
task);
}
@@ -962,16 +1085,55 @@ rest_proxy_call_invoke_finish (RestProxyCall *call,
}
static void
-_continuous_call_message_got_chunk_cb (SoupMessage *msg,
- SoupBuffer *chunk,
- RestProxyCallContinuousClosure *closure)
+_continuous_call_read_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
{
+ GInputStream *stream = G_INPUT_STREAM (source);
+ RestProxyCallContinuousClosure *closure = user_data;
+ RestProxyCallPrivate *priv = GET_PRIVATE (closure->call);
+ gssize bytes_read;
+ GError *error = NULL;
+
+ bytes_read = g_input_stream_read_finish (stream, result, &error);
+ if (bytes_read <= 0)
+ {
+ _continuous_call_message_completed (closure->message, error, user_data);
+ return;
+ }
+
closure->callback (closure->call,
- chunk->data,
- chunk->length,
+ (gconstpointer)closure->buffer,
+ bytes_read,
NULL,
closure->weak_object,
closure->userdata);
+
+ g_input_stream_read_async (stream, closure->buffer, READ_BUFFER_SIZE, G_PRIORITY_DEFAULT,
+ priv->cancellable, _continuous_call_read_cb, closure);
+}
+
+static void
+_continuous_call_message_sent_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ RestProxy *proxy = REST_PROXY (source);
+ RestProxyCallContinuousClosure *closure = user_data;
+ RestProxyCallPrivate *priv = GET_PRIVATE (closure->call);
+ GInputStream *stream;
+ GError *error = NULL;
+
+ stream = _rest_proxy_send_message_finish (proxy, result, &error);
+ if (!stream)
+ {
+ _continuous_call_message_completed (closure->message, error, user_data);
+ return;
+ }
+
+ g_input_stream_read_async (stream, closure->buffer, READ_BUFFER_SIZE, G_PRIORITY_DEFAULT,
+ priv->cancellable, _continuous_call_read_cb, closure);
+ g_object_unref (stream);
}
@@ -1021,9 +1183,6 @@ rest_proxy_call_continuous (RestProxyCall *call,
if (message == NULL)
return FALSE;
- /* Must turn off accumulation */
- soup_message_body_set_accumulate (message->response_body, FALSE);
-
closure = g_slice_new0 (RestProxyCallContinuousClosure);
closure->call = g_object_ref (call);
closure->callback = callback;
@@ -1041,33 +1200,29 @@ rest_proxy_call_continuous (RestProxyCall *call,
closure);
}
- g_signal_connect (message,
- "got-chunk",
- (GCallback)_continuous_call_message_got_chunk_cb,
- closure);
-
- _rest_proxy_queue_message (priv->proxy,
- message,
- _continuous_call_message_completed_cb,
- closure);
+ _rest_proxy_send_message_async (priv->proxy,
+ message,
+ priv->cancellable,
+ _continuous_call_message_sent_cb,
+ closure);
return TRUE;
}
static void
-_upload_call_message_completed_cb (SoupSession *session,
- SoupMessage *message,
+_upload_call_message_completed_cb (SoupMessage *message,
+ GBytes *payload,
+ GError *error,
gpointer user_data)
{
RestProxyCall *call;
RestProxyCallPrivate *priv;
- GError *error = NULL;
RestProxyCallUploadClosure *closure;
closure = (RestProxyCallUploadClosure *) user_data;
call = closure->call;
priv = GET_PRIVATE (call);
- finish_call (call, message, &error);
+ finish_call (call, message, payload, &error);
closure->callback (closure->call,
closure->uploaded,
@@ -1093,14 +1248,25 @@ _upload_call_message_completed_cb (SoupSession *session,
static void
_upload_call_message_wrote_data_cb (SoupMessage *msg,
+#ifdef WITH_SOUP_2
SoupBuffer *chunk,
+#else
+ gsize chunk_size,
+#endif
RestProxyCallUploadClosure *closure)
{
- closure->uploaded = closure->uploaded + chunk->length;
+#ifdef WITH_SOUP_2
+ gsize chunk_size = chunk->length;
+ goffset content_length = msg->request_body->length;
+#else
+ goffset content_length = soup_message_headers_get_content_length (soup_message_get_request_headers (msg));
+#endif
- if (closure->uploaded < msg->request_body->length)
+ closure->uploaded = closure->uploaded + chunk_size;
+
+ if (closure->uploaded < content_length)
closure->callback (closure->call,
- msg->request_body->length,
+ content_length,
closure->uploaded,
NULL,
closure->weak_object,
@@ -1178,6 +1344,7 @@ rest_proxy_call_upload (RestProxyCall *call,
_rest_proxy_queue_message (priv->proxy,
message,
+ priv->cancellable,
_upload_call_message_completed_cb,
closure);
return TRUE;
@@ -1206,6 +1373,10 @@ rest_proxy_call_cancel (RestProxyCall *call)
if (priv->cancellable)
{
g_signal_handler_disconnect (priv->cancellable, priv->cancel_sig);
+#ifndef WITH_SOUP_2
+ if (!g_cancellable_is_cancelled (priv->cancellable))
+ g_cancellable_cancel (priv->cancellable);
+#endif
g_clear_object (&priv->cancellable);
}
@@ -1240,6 +1411,7 @@ rest_proxy_call_sync (RestProxyCall *call,
RestProxyCallPrivate *priv = GET_PRIVATE (call);
SoupMessage *message;
gboolean ret;
+ GBytes *payload;
g_return_val_if_fail (REST_IS_PROXY_CALL (call), FALSE);
@@ -1247,9 +1419,9 @@ rest_proxy_call_sync (RestProxyCall *call,
if (!message)
return FALSE;
- _rest_proxy_send_message (priv->proxy, message);
+ payload = _rest_proxy_send_message (priv->proxy, message, priv->cancellable, error_out);
- ret = finish_call (call, message, error_out);
+ ret = finish_call (call, message, payload, error_out);
g_object_unref (message);
@@ -1314,9 +1486,16 @@ rest_proxy_call_get_response_headers (RestProxyCall *call)
goffset
rest_proxy_call_get_payload_length (RestProxyCall *call)
{
+ GBytes *payload;
+
g_return_val_if_fail (REST_IS_PROXY_CALL (call), 0);
- return GET_PRIVATE (call)->length;
+ payload = GET_PRIVATE (call)->payload;
+#ifdef WITH_SOUP_2
+ return payload ? g_bytes_get_size (payload) - 1 : 0;
+#else
+ return payload ? g_bytes_get_size (payload) : 0;
+#endif
}
/**
@@ -1331,9 +1510,12 @@ rest_proxy_call_get_payload_length (RestProxyCall *call)
const gchar *
rest_proxy_call_get_payload (RestProxyCall *call)
{
+ GBytes *payload;
+
g_return_val_if_fail (REST_IS_PROXY_CALL (call), NULL);
- return GET_PRIVATE (call)->payload;
+ payload = GET_PRIVATE (call)->payload;
+ return payload ? g_bytes_get_data (payload, NULL) : NULL;
}
/**
diff --git a/rest/rest-proxy.c b/rest/rest-proxy.c
index 80972a3..171f6cb 100644
--- a/rest/rest-proxy.c
+++ b/rest/rest-proxy.c
@@ -45,6 +45,9 @@ struct _RestProxyPrivate {
SoupSession *session;
gboolean disable_cookies;
char *ssl_ca_file;
+#ifndef WITH_SOUP_2
+ gboolean ssl_strict;
+#endif
};
@@ -116,11 +119,15 @@ rest_proxy_get_property (GObject *object,
g_value_set_string (value, priv->password);
break;
case PROP_SSL_STRICT: {
+#ifdef WITH_SOUP_2
gboolean ssl_strict;
g_object_get (G_OBJECT(priv->session),
"ssl-strict", &ssl_strict,
NULL);
g_value_set_boolean (value, ssl_strict);
+#else
+ g_value_set_boolean (value, priv->ssl_strict);
+#endif
break;
}
case PROP_SSL_CA_FILE:
@@ -172,9 +179,13 @@ rest_proxy_set_property (GObject *object,
priv->password = g_value_dup_string (value);
break;
case PROP_SSL_STRICT:
+#ifdef WITH_SOUP_2
g_object_set (G_OBJECT(priv->session),
"ssl-strict", g_value_get_boolean (value),
NULL);
+#else
+ priv->ssl_strict = g_value_get_boolean (value);
+#endif
break;
case PROP_SSL_CA_FILE:
g_free(priv->ssl_ca_file);
@@ -207,6 +218,7 @@ default_authenticate_cb (RestProxy *self,
return !retrying;
}
+#ifdef WITH_SOUP_2
static void
authenticate (RestProxy *self,
SoupMessage *msg,
@@ -224,6 +236,7 @@ authenticate (RestProxy *self,
soup_auth_authenticate (soup_auth, priv->username, priv->password);
g_object_unref (G_OBJECT (rest_auth));
}
+#endif
static void
rest_proxy_constructed (GObject *object)
@@ -238,14 +251,20 @@ rest_proxy_constructed (GObject *object)
}
if (REST_DEBUG_ENABLED(PROXY)) {
+#ifdef WITH_SOUP_2
SoupSessionFeature *logger = (SoupSessionFeature*)soup_logger_new (SOUP_LOGGER_LOG_BODY, 0);
+#else
+ SoupSessionFeature *logger = (SoupSessionFeature*)soup_logger_new (SOUP_LOGGER_LOG_HEADERS);
+#endif
soup_session_add_feature (priv->session, logger);
g_object_unref (logger);
}
+#ifdef WITH_SOUP_2
/* session lifetime is same as self, no need to keep signalid */
g_signal_connect_swapped (priv->session, "authenticate",
G_CALLBACK(authenticate), object);
+#endif
}
static void
@@ -391,23 +410,62 @@ rest_proxy_class_init (RestProxyClass *klass)
proxy_class->authenticate = default_authenticate_cb;
}
+static gboolean
+transform_ssl_ca_file_to_tls_database (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data)
+{
+ g_value_take_object (to_value,
+ g_tls_file_database_new (g_value_get_string (from_value), NULL));
+ return TRUE;
+}
+
+static gboolean
+transform_tls_database_to_ssl_ca_file (GBinding *binding,
+ const GValue *from_value,
+ GValue *to_value,
+ gpointer user_data)
+{
+ GTlsDatabase *tls_database;
+ char *path = NULL;
+
+ tls_database = g_value_get_object (from_value);
+ if (tls_database)
+ g_object_get (tls_database, "anchors", &path, NULL);
+ g_value_take_string (to_value, path);
+ return TRUE;
+}
+
static void
rest_proxy_init (RestProxy *self)
{
RestProxyPrivate *priv = GET_PRIVATE (self);
+ GTlsDatabase *tls_database;
+
+#ifndef WITH_SOUP_2
+ priv->ssl_strict = TRUE;
+#endif
priv->session = soup_session_new ();
#ifdef REST_SYSTEM_CA_FILE
/* with ssl-strict (defaults TRUE) setting ssl-ca-file forces all
* certificates to be trusted */
- g_object_set (priv->session,
- "ssl-ca-file", REST_SYSTEM_CA_FILE,
- NULL);
+ tls_database = g_tls_file_database_new (REST_SYSTEM_CA_FILE, NULL);
+ if (tls_database) {
+ g_object_set (priv->session,
+ "tls-database", tls_database,
+ NULL);
+ g_object_unref (tls_database);
+ }
#endif
- g_object_bind_property (self, "ssl-ca-file",
- priv->session, "ssl-ca-file",
- G_BINDING_BIDIRECTIONAL);
+ g_object_bind_property_full (self, "ssl-ca-file",
+ priv->session, "tls-database",
+ G_BINDING_BIDIRECTIONAL,
+ transform_ssl_ca_file_to_tls_database,
+ transform_tls_database_to_ssl_ca_file,
+ NULL, NULL);
}
/**
@@ -689,27 +747,127 @@ rest_proxy_simple_run (RestProxy *proxy,
return ret;
}
+typedef struct {
+ RestMessageFinishedCallback callback;
+ gpointer user_data;
+} RestMessageQueueData;
+
+#ifdef WITH_SOUP_2
+static void
+message_finished_cb (SoupSession *session,
+ SoupMessage *message,
+ gpointer user_data)
+{
+ RestMessageQueueData *data = user_data;
+ GBytes *body;
+ GError *error = NULL;
+
+ body = g_bytes_new (message->response_body->data,
+ message->response_body->length + 1);
+ data->callback (message, body, error, data->user_data);
+ g_free (data);
+}
+#else
+static void
+message_send_and_read_ready_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ SoupSession *session = SOUP_SESSION (source);
+ RestMessageQueueData *data = user_data;
+ GBytes *body;
+ GError *error = NULL;
+
+ body = soup_session_send_and_read_finish (session, result, &error);
+ data->callback (soup_session_get_async_result_message (session, result), body, error, data->user_data);
+ g_free (data);
+}
+#endif
+
void
-_rest_proxy_queue_message (RestProxy *proxy,
- SoupMessage *message,
- SoupSessionCallback callback,
- gpointer user_data)
+_rest_proxy_queue_message (RestProxy *proxy,
+ SoupMessage *message,
+ GCancellable *cancellable,
+ RestMessageFinishedCallback callback,
+ gpointer user_data)
{
RestProxyPrivate *priv = GET_PRIVATE (proxy);
+ RestMessageQueueData *data;
g_return_if_fail (REST_IS_PROXY (proxy));
g_return_if_fail (SOUP_IS_MESSAGE (message));
+ data = g_new0 (RestMessageQueueData, 1);
+ data->callback = callback;
+ data->user_data = user_data;
+
+#ifdef WITH_SOUP_2
soup_session_queue_message (priv->session,
message,
- callback,
- user_data);
+ message_finished_cb,
+ data);
+#else
+ soup_session_send_and_read_async (priv->session,
+ message,
+ G_PRIORITY_DEFAULT,
+ cancellable,
+ message_send_and_read_ready_cb,
+ data);
+#endif
+}
+
+static void
+message_send_ready_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ SoupSession *session = SOUP_SESSION (source);
+ GTask *task = user_data;
+ GInputStream *stream;
+ GError *error = NULL;
+
+ stream = soup_session_send_finish (session, result, &error);
+ if (stream)
+ g_task_return_pointer (task, stream, g_object_unref);
+ else
+ g_task_return_error (task, error);
+ g_object_unref (task);
+}
+
+void
+_rest_proxy_send_message_async (RestProxy *proxy,
+ SoupMessage *message,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ RestProxyPrivate *priv = GET_PRIVATE (proxy);
+ GTask *task;
+
+ task = g_task_new (proxy, cancellable, callback, user_data);
+ soup_session_send_async (priv->session,
+ message,
+#ifndef WITH_SOUP_2
+ G_PRIORITY_DEFAULT,
+#endif
+ cancellable,
+ message_send_ready_cb,
+ task);
+}
+
+GInputStream *
+_rest_proxy_send_message_finish (RestProxy *proxy,
+ GAsyncResult *result,
+ GError **error)
+{
+ return g_task_propagate_pointer (G_TASK (result), error);
}
void
_rest_proxy_cancel_message (RestProxy *proxy,
SoupMessage *message)
{
+#ifdef WITH_SOUP_2
RestProxyPrivate *priv = GET_PRIVATE (proxy);
g_return_if_fail (REST_IS_PROXY (proxy));
@@ -718,16 +876,31 @@ _rest_proxy_cancel_message (RestProxy *proxy,
soup_session_cancel_message (priv->session,
message,
SOUP_STATUS_CANCELLED);
+#endif
}
-guint
-_rest_proxy_send_message (RestProxy *proxy,
- SoupMessage *message)
+GBytes *
+_rest_proxy_send_message (RestProxy *proxy,
+ SoupMessage *message,
+ GCancellable *cancellable,
+ GError **error)
{
RestProxyPrivate *priv = GET_PRIVATE (proxy);
+ GBytes *body;
- g_return_val_if_fail (REST_IS_PROXY (proxy), 0);
- g_return_val_if_fail (SOUP_IS_MESSAGE (message), 0);
+ g_return_val_if_fail (REST_IS_PROXY (proxy), NULL);
+ g_return_val_if_fail (SOUP_IS_MESSAGE (message), NULL);
+
+#ifdef WITH_SOUP_2
+ soup_session_send_message (priv->session, message);
+ body = g_bytes_new (message->response_body->data,
+ message->response_body->length + 1);
+#else
+ body = soup_session_send_and_read (priv->session,
+ message,
+ cancellable,
+ error);
+#endif
- return soup_session_send_message (priv->session, message);
+ return body;
}
diff --git a/tests/custom-serialize.c b/tests/custom-serialize.c
index c3fde93..01b3a56 100644
--- a/tests/custom-serialize.c
+++ b/tests/custom-serialize.c
@@ -88,22 +88,40 @@ custom_proxy_call_init (CustomProxyCall *self)
}
static void
+#ifdef WITH_SOUP_2
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *client, gpointer user_data)
+#else
+server_callback (SoupServer *server, SoupServerMessage *msg,
+ const char *path, GHashTable *query, gpointer user_data)
+#endif
{
if (g_str_equal (path, "/ping")) {
const char *content_type = NULL;
+#ifdef WITH_SOUP_2
SoupMessageHeaders *headers = msg->request_headers;
SoupMessageBody *body = msg->request_body;
+#else
+ SoupMessageHeaders *headers = soup_server_message_get_request_headers (msg);
+ SoupMessageBody *body = soup_server_message_get_request_body (msg);
+#endif
content_type = soup_message_headers_get_content_type (headers, NULL);
g_assert_cmpstr (content_type, ==, "application/json");
g_assert_cmpstr (body->data, ==, "{}");
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
} else {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
+#endif
}
}
diff --git a/tests/proxy-continuous.c b/tests/proxy-continuous.c
index 8f4b7a8..7967bbd 100644
--- a/tests/proxy-continuous.c
+++ b/tests/proxy-continuous.c
@@ -39,9 +39,15 @@ static SoupServer *server;
static gboolean
send_chunks (gpointer user_data)
{
- SoupMessage *msg = SOUP_MESSAGE (user_data);
guint i;
guint8 data[SIZE_CHUNK];
+#ifdef WITH_SOUP_2
+ SoupMessage *msg = SOUP_MESSAGE (user_data);
+ SoupMessageBody *response_body = msg->response_body;
+#else
+ SoupServerMessage *msg = SOUP_SERVER_MESSAGE (user_data);
+ SoupMessageBody *response_body = soup_server_message_get_response_body (msg);
+#endif
for (i = 0; i < SIZE_CHUNK; i++)
{
@@ -49,12 +55,12 @@ send_chunks (gpointer user_data)
server_count++;
}
- soup_message_body_append (msg->response_body, SOUP_MEMORY_COPY, data, SIZE_CHUNK);
+ soup_message_body_append (response_body, SOUP_MEMORY_COPY, data, SIZE_CHUNK);
soup_server_unpause_message (server, msg);
if (server_count == NUM_CHUNKS * SIZE_CHUNK)
{
- soup_message_body_complete (msg->response_body);
+ soup_message_body_complete (response_body);
return FALSE;
} else {
return TRUE;
@@ -62,13 +68,28 @@ send_chunks (gpointer user_data)
}
static void
+#ifdef WITH_SOUP_2
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *client, gpointer user_data)
+#else
+server_callback (SoupServer *server, SoupServerMessage *msg,
+ const char *path, GHashTable *query, gpointer user_data)
+#endif
{
+#ifdef WITH_SOUP_2
+ SoupMessageHeaders *response_headers = msg->response_headers;
+#else
+ SoupMessageHeaders *response_headers = soup_server_message_get_response_headers (msg);
+#endif
+
g_assert_cmpstr (path, ==, "/stream");
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
- soup_message_headers_set_encoding (msg->response_headers,
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
+ soup_message_headers_set_encoding (response_headers,
SOUP_ENCODING_CHUNKED);
soup_server_pause_message (server, msg);
@@ -142,13 +163,21 @@ continuous ()
uris = soup_server_get_uris (server);
g_assert (g_slist_length (uris) > 0);
+#ifdef WITH_SOUP_2
url = soup_uri_to_string (uris->data, FALSE);
+#else
+ url = g_uri_to_string (uris->data);
+#endif
loop = g_main_loop_new (NULL, FALSE);
proxy = rest_proxy_new (url, FALSE);
stream_test (proxy);
+#ifdef WITH_SOUP_2
g_slist_free_full (uris, (GDestroyNotify)soup_uri_free);
+#else
+ g_slist_free_full (uris, (GDestroyNotify)g_uri_unref);
+#endif
g_main_loop_run (loop);
g_free (url);
diff --git a/tests/proxy.c b/tests/proxy.c
index 89a9325..652c600 100644
--- a/tests/proxy.c
+++ b/tests/proxy.c
@@ -49,20 +49,35 @@ SoupServer *server;
GMainLoop *server_loop;
static void
+#ifdef WITH_SOUP_2
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *client, gpointer user_data)
+#else
+server_callback (SoupServer *server, SoupServerMessage *msg,
+ const char *path, GHashTable *query, gpointer user_data)
+#endif
{
if (g_str_equal (path, "/ping")) {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
}
else if (g_str_equal (path, "/echo")) {
const char *value;
value = g_hash_table_lookup (query, "value");
+#ifdef WITH_SOUP_2
soup_message_set_response (msg, "text/plain", SOUP_MEMORY_COPY,
value, strlen (value));
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_response (msg, "text/plain", SOUP_MEMORY_COPY,
+ value, strlen (value));
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
}
else if (g_str_equal (path, "/reverse")) {
char *value;
@@ -70,9 +85,15 @@ server_callback (SoupServer *server, SoupMessage *msg,
value = g_strdup (g_hash_table_lookup (query, "value"));
g_strreverse (value);
+#ifdef WITH_SOUP_2
soup_message_set_response (msg, "text/plain", SOUP_MEMORY_TAKE,
value, strlen (value));
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_response (msg, "text/plain", SOUP_MEMORY_TAKE,
+ value, strlen (value));
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
}
else if (g_str_equal (path, "/status")) {
const char *value;
@@ -81,25 +102,61 @@ server_callback (SoupServer *server, SoupMessage *msg,
value = g_hash_table_lookup (query, "status");
if (value) {
status = atoi (value);
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, status ?: SOUP_STATUS_INTERNAL_SERVER_ERROR);
+#else
+ soup_server_message_set_status (msg, status ?: SOUP_STATUS_INTERNAL_SERVER_ERROR, NULL);
+#endif
} else {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR, NULL);
+#endif
}
}
else if (g_str_equal (path, "/useragent/none")) {
- if (soup_message_headers_get (msg->request_headers, "User-Agent") == NULL) {
+#ifdef WITH_SOUP_2
+ SoupMessageHeaders *request_headers = msg->request_headers;
+#else
+ SoupMessageHeaders *request_headers = soup_server_message_get_request_headers (msg);
+#endif
+
+ if (soup_message_headers_get (request_headers, "User-Agent") == NULL) {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
} else {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_EXPECTATION_FAILED);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_EXPECTATION_FAILED, NULL);
+#endif
}
}
else if (g_str_equal (path, "/useragent/testsuite")) {
+#ifdef WITH_SOUP_2
+ SoupMessageHeaders *request_headers = msg->request_headers;
+#else
+ SoupMessageHeaders *request_headers = soup_server_message_get_request_headers (msg);
+#endif
const char *value;
- value = soup_message_headers_get (msg->request_headers, "User-Agent");
+ value = soup_message_headers_get (request_headers, "User-Agent");
if (g_strcmp0 (value, "TestSuite-1.0") == 0) {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
} else {
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_EXPECTATION_FAILED);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_EXPECTATION_FAILED, NULL);
+#endif
+
}
}
}
@@ -325,7 +382,7 @@ main (int argc, char **argv)
char *url;
RestProxy *proxy;
- server = soup_server_new ("", NULL);
+ server = soup_server_new (NULL);
g_thread_new ("Server Thread", server_thread_func, NULL);
url = g_strdup_printf ("http://127.0.0.1:%d/", PORT);
diff --git a/tests/threaded.c b/tests/threaded.c
index a251900..411361c 100644
--- a/tests/threaded.c
+++ b/tests/threaded.c
@@ -36,13 +36,22 @@ GMainLoop *main_loop;
SoupServer *server;
static void
+#ifdef WITH_SOUP_2
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *client, gpointer user_data)
+#else
+server_callback (SoupServer *server, SoupServerMessage *msg,
+ const char *path, GHashTable *query, gpointer user_data)
+#endif
{
g_assert_cmpstr (path, ==, "/ping");
+#ifdef WITH_SOUP_2
soup_message_set_status (msg, SOUP_STATUS_OK);
+#else
+ soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+#endif
g_atomic_int_add (&threads_done, 1);
if (threads_done == N_THREADS) {
@@ -96,7 +105,11 @@ static void ping ()
uris = soup_server_get_uris (server);
g_assert (g_slist_length (uris) > 0);
+#ifdef WITH_SOUP_2
url = soup_uri_to_string (uris->data, FALSE);
+#else
+ url = g_uri_to_string (uris->data);
+#endif
main_loop = g_main_loop_new (NULL, TRUE);
@@ -109,7 +122,11 @@ static void ping ()
g_main_loop_run (main_loop);
g_free (url);
+#ifdef WITH_SOUP_2
g_slist_free_full (uris, (GDestroyNotify)soup_uri_free);
+#else
+ g_slist_free_full (uris, (GDestroyNotify)g_uri_unref);
+#endif
g_object_unref (server);
g_main_loop_unref (main_loop);
}
--
2.33.1
Reference in New Issue View Git Blame Copy Permalink