From dbc7ce9e0f5bf9c8be764946886a9003fb129b29 Mon Sep 17 00:00:00 2001 From: Dan Winship Date: Mon, 11 Apr 2005 20:42:07 +0000 Subject: [PATCH] require glib-2.0 >= 2.4.0 * configure.in: require glib-2.0 >= 2.4.0 * libsoup/*.c: use G_DEFINE_TYPE and g_type_class_add_private/G_TYPE_INSTANCE_GET_PRIVATE * libsoup/soup-types.h: kill SOUP_MAKE_TYPE and SOUP_MAKE_TYPE_WITH_IFACE * tests/revserver.c: use GThread. (patch from tml) --- ChangeLog | 12 ++ configure.in | 2 +- libsoup/soup-address.c | 202 ++++++++++---------- libsoup/soup-address.h | 3 - libsoup/soup-auth-basic.c | 51 ++--- libsoup/soup-auth-basic.h | 3 - libsoup/soup-auth-digest.c | 170 ++++++++--------- libsoup/soup-auth-digest.h | 3 - libsoup/soup-auth.c | 12 +- libsoup/soup-connection-ntlm.c | 72 ++++--- libsoup/soup-connection-ntlm.h | 3 - libsoup/soup-connection.c | 253 +++++++++++++------------ libsoup/soup-connection.h | 3 - libsoup/soup-message-client-io.c | 10 +- libsoup/soup-message-handlers.c | 18 +- libsoup/soup-message-io.c | 47 +++-- libsoup/soup-message-private.h | 5 +- libsoup/soup-message-server-io.c | 7 +- libsoup/soup-message.c | 90 ++++----- libsoup/soup-message.h | 4 - libsoup/soup-server-message.c | 56 +++--- libsoup/soup-server-message.h | 3 - libsoup/soup-server.c | 235 ++++++++++++----------- libsoup/soup-server.h | 3 - libsoup/soup-session-async.c | 33 +--- libsoup/soup-session-async.h | 3 - libsoup/soup-session-sync.c | 57 +++--- libsoup/soup-session-sync.h | 3 - libsoup/soup-session.c | 245 +++++++++++++----------- libsoup/soup-session.h | 4 - libsoup/soup-soap-message.c | 265 +++++++++++++++----------- libsoup/soup-soap-message.h | 4 +- libsoup/soup-soap-response.c | 120 ++++++------ libsoup/soup-soap-response.h | 4 +- libsoup/soup-socket.c | 400 +++++++++++++++++++++------------------ libsoup/soup-socket.h | 3 - libsoup/soup-types.h | 54 ------ tests/revserver.c | 13 +- 38 files changed, 1247 insertions(+), 1228 deletions(-) diff --git a/ChangeLog b/ChangeLog index f41a57c..575fc58 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,17 @@ 2005-04-11 Dan Winship + * configure.in: require glib-2.0 >= 2.4.0 + + * libsoup/*.c: use G_DEFINE_TYPE and + g_type_class_add_private/G_TYPE_INSTANCE_GET_PRIVATE + + * libsoup/soup-types.h: kill SOUP_MAKE_TYPE and + SOUP_MAKE_TYPE_WITH_IFACE + + * tests/revserver.c: use GThread. (patch from tml) + +2005-04-11 Dan Winship + * configure.in: bump version to 2.3.0. bump SOUP_API_VERSION to 2.4 diff --git a/configure.in b/configure.in index 5f66a3d..ac03ab8 100644 --- a/configure.in +++ b/configure.in @@ -72,7 +72,7 @@ dnl *********************** dnl *** Checks for glib *** dnl *********************** -AM_PATH_GLIB_2_0(2.0.0,,,gobject gthread) +AM_PATH_GLIB_2_0(2.4.0,,,gobject gthread) PKG_CHECK_MODULES(XML, libxml-2.0) AC_SUBST(XML_CFLAGS) diff --git a/libsoup/soup-address.c b/libsoup/soup-address.c index c4d42ac..4d00678 100644 --- a/libsoup/soup-address.c +++ b/libsoup/soup-address.c @@ -36,7 +36,7 @@ #define INADDR_NONE -1 #endif -struct SoupAddressPrivate { +typedef struct { struct sockaddr *sockaddr; char *name, *physical; @@ -44,19 +44,19 @@ struct SoupAddressPrivate { SoupDNSEntry *lookup; guint timeout_id; -}; - +} SoupAddressPrivate; +#define SOUP_ADDRESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_ADDRESS, SoupAddressPrivate)) /* sockaddr generic macros */ -#define SOUP_SIN(addr) ((struct sockaddr_in *)addr->priv->sockaddr) +#define SOUP_SIN(priv) ((struct sockaddr_in *)priv->sockaddr) #ifdef HAVE_IPV6 -#define SOUP_SIN6(addr) ((struct sockaddr_in6 *)addr->priv->sockaddr) +#define SOUP_SIN6(priv) ((struct sockaddr_in6 *)priv->sockaddr) #endif /* sockaddr family macros */ -#define SOUP_ADDRESS_GET_FAMILY(addr) (addr->priv->sockaddr->sa_family) -#define SOUP_ADDRESS_SET_FAMILY(addr, family) \ - (addr->priv->sockaddr->sa_family = family) +#define SOUP_ADDRESS_GET_FAMILY(priv) (priv->sockaddr->sa_family) +#define SOUP_ADDRESS_SET_FAMILY(priv, family) \ + (priv->sockaddr->sa_family = family) #ifdef HAVE_IPV6 #define SOUP_ADDRESS_FAMILY_IS_VALID(family) \ (family == AF_INET || family == AF_INET6) @@ -75,33 +75,33 @@ struct SoupAddressPrivate { /* sockaddr port macros */ #define SOUP_ADDRESS_PORT_IS_VALID(port) (port >= 0 && port <= 65535) #ifdef HAVE_IPV6 -#define SOUP_ADDRESS_GET_PORT(addr) \ - (addr->priv->sockaddr->sa_family == AF_INET ? \ - SOUP_SIN(addr)->sin_port : \ - SOUP_SIN6(addr)->sin6_port) -#define SOUP_ADDRESS_SET_PORT(addr, port) \ +#define SOUP_ADDRESS_GET_PORT(priv) \ + (priv->sockaddr->sa_family == AF_INET ? \ + SOUP_SIN(priv)->sin_port : \ + SOUP_SIN6(priv)->sin6_port) +#define SOUP_ADDRESS_SET_PORT(priv, port) \ G_STMT_START { \ - if (addr->priv->sockaddr->sa_family == AF_INET) \ - SOUP_SIN(addr)->sin_port = port; \ + if (priv->sockaddr->sa_family == AF_INET) \ + SOUP_SIN(priv)->sin_port = port; \ else \ - SOUP_SIN6(addr)->sin6_port = port; \ + SOUP_SIN6(priv)->sin6_port = port; \ } G_STMT_END #else -#define SOUP_ADDRESS_GET_PORT(addr) (SOUP_SIN(addr)->sin_port) -#define SOUP_ADDRESS_SET_PORT(addr, port) (SOUP_SIN(addr)->sin_port = port) +#define SOUP_ADDRESS_GET_PORT(priv) (SOUP_SIN(priv)->sin_port) +#define SOUP_ADDRESS_SET_PORT(priv, port) (SOUP_SIN(priv)->sin_port = port) #endif /* sockaddr data macros */ #ifdef HAVE_IPV6 -#define SOUP_ADDRESS_GET_DATA(addr) \ - (addr->priv->sockaddr->sa_family == AF_INET ? \ - (gpointer)&SOUP_SIN(addr)->sin_addr : \ - (gpointer)&SOUP_SIN6(addr)->sin6_addr) +#define SOUP_ADDRESS_GET_DATA(priv) \ + (priv->sockaddr->sa_family == AF_INET ? \ + (gpointer)&SOUP_SIN(priv)->sin_addr : \ + (gpointer)&SOUP_SIN6(priv)->sin6_addr) #else -#define SOUP_ADDRESS_GET_DATA(addr) ((gpointer)&SOUP_SIN(addr)->sin_addr) +#define SOUP_ADDRESS_GET_DATA(priv) ((gpointer)&SOUP_SIN(priv)->sin_addr) #endif -#define SOUP_ADDRESS_SET_DATA(addr, data, length) \ - memcpy (SOUP_ADDRESS_GET_DATA (addr), data, length) +#define SOUP_ADDRESS_SET_DATA(priv, data, length) \ + memcpy (SOUP_ADDRESS_GET_DATA (priv), data, length) enum { @@ -111,43 +111,40 @@ enum { static guint signals[LAST_SIGNAL] = { 0 }; -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupAddress, soup_address, G_TYPE_OBJECT) static void -init (GObject *object) +soup_address_init (SoupAddress *addr) { - SoupAddress *addr = SOUP_ADDRESS (object); - - addr->priv = g_new0 (SoupAddressPrivate, 1); } static void finalize (GObject *object) { SoupAddress *addr = SOUP_ADDRESS (object); + SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); - if (addr->priv->sockaddr) - g_free (addr->priv->sockaddr); - if (addr->priv->name) - g_free (addr->priv->name); - if (addr->priv->physical) - g_free (addr->priv->physical); - - if (addr->priv->lookup) - soup_dns_entry_cancel_lookup (addr->priv->lookup); - if (addr->priv->timeout_id) - g_source_remove (addr->priv->timeout_id); + if (priv->sockaddr) + g_free (priv->sockaddr); + if (priv->name) + g_free (priv->name); + if (priv->physical) + g_free (priv->physical); - g_free (addr->priv); + if (priv->lookup) + soup_dns_entry_cancel_lookup (priv->lookup); + if (priv->timeout_id) + g_source_remove (priv->timeout_id); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_address_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_address_class_init (SoupAddressClass *address_class) { - parent_class = g_type_class_ref (PARENT_TYPE); + GObjectClass *object_class = G_OBJECT_CLASS (address_class); + + g_type_class_add_private (address_class, sizeof (SoupAddressPrivate)); /* virtual method override */ object_class->finalize = finalize; @@ -164,9 +161,6 @@ class_init (GObjectClass *object_class) G_TYPE_INT); } -SOUP_MAKE_TYPE (soup_address, SoupAddress, class_init, init, PARENT_TYPE) - - /** * soup_address_new: @@ -184,13 +178,15 @@ SoupAddress * soup_address_new (const char *name, guint port) { SoupAddress *addr; + SoupAddressPrivate *priv; g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL); addr = g_object_new (SOUP_TYPE_ADDRESS, NULL); - addr->priv->name = g_strdup (name); - addr->priv->port = port; + priv = SOUP_ADDRESS_GET_PRIVATE (addr); + priv->name = g_strdup (name); + priv->port = port; return addr; } @@ -209,14 +205,16 @@ SoupAddress * soup_address_new_from_sockaddr (struct sockaddr *sa, int len) { SoupAddress *addr; + SoupAddressPrivate *priv; g_return_val_if_fail (sa != NULL, NULL); g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (sa->sa_family), NULL); g_return_val_if_fail (len == SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (sa->sa_family), NULL); addr = g_object_new (SOUP_TYPE_ADDRESS, NULL); - addr->priv->sockaddr = g_memdup (sa, len); - addr->priv->port = ntohs (SOUP_ADDRESS_GET_PORT (addr)); + priv = SOUP_ADDRESS_GET_PRIVATE (addr); + priv->sockaddr = g_memdup (sa, len); + priv->port = ntohs (SOUP_ADDRESS_GET_PORT (priv)); return addr; } @@ -235,17 +233,18 @@ SoupAddress * soup_address_new_any (SoupAddressFamily family, guint port) { SoupAddress *addr; + SoupAddressPrivate *priv; g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (family), NULL); g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL); addr = g_object_new (SOUP_TYPE_ADDRESS, NULL); - addr->priv->port = port; + priv = SOUP_ADDRESS_GET_PRIVATE (addr); + priv->port = port; - addr->priv->sockaddr = - g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (family)); - SOUP_ADDRESS_SET_FAMILY (addr, family); - SOUP_ADDRESS_SET_PORT (addr, htons (port)); + priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (family)); + SOUP_ADDRESS_SET_FAMILY (priv, family); + SOUP_ADDRESS_SET_PORT (priv, htons (port)); return addr; } @@ -263,7 +262,7 @@ soup_address_get_name (SoupAddress *addr) { g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL); - return addr->priv->name; + return SOUP_ADDRESS_GET_PRIVATE (addr)->name; } /** @@ -279,12 +278,15 @@ soup_address_get_name (SoupAddress *addr) struct sockaddr * soup_address_get_sockaddr (SoupAddress *addr, int *len) { + SoupAddressPrivate *priv; + g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL); + priv = SOUP_ADDRESS_GET_PRIVATE (addr); - if (addr->priv->sockaddr && len) - *len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (addr)); + if (priv->sockaddr && len) + *len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (priv)); - return addr->priv->sockaddr; + return priv->sockaddr; } /** @@ -299,18 +301,21 @@ soup_address_get_sockaddr (SoupAddress *addr, int *len) const char * soup_address_get_physical (SoupAddress *addr) { + SoupAddressPrivate *priv; + g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL); + priv = SOUP_ADDRESS_GET_PRIVATE (addr); - if (!addr->priv->sockaddr) + if (!priv->sockaddr) return NULL; - if (!addr->priv->physical) { - addr->priv->physical = - soup_dns_ntop (SOUP_ADDRESS_GET_DATA (addr), - SOUP_ADDRESS_GET_FAMILY (addr)); + if (!priv->physical) { + priv->physical = + soup_dns_ntop (SOUP_ADDRESS_GET_DATA (priv), + SOUP_ADDRESS_GET_FAMILY (priv)); } - return addr->priv->physical; + return priv->physical; } /** @@ -326,34 +331,35 @@ soup_address_get_port (SoupAddress *addr) { g_return_val_if_fail (SOUP_IS_ADDRESS (addr), 0); - return addr->priv->port; + return SOUP_ADDRESS_GET_PRIVATE (addr)->port; } static guint update_address_from_entry (SoupAddress *addr, SoupDNSEntry *entry) { + SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); struct hostent *h; h = soup_dns_entry_get_hostent (entry); if (!h) return SOUP_STATUS_CANT_RESOLVE; - if (!addr->priv->name) - addr->priv->name = g_strdup (h->h_name); + if (!priv->name) + priv->name = g_strdup (h->h_name); - if (!addr->priv->sockaddr && + if (!priv->sockaddr && SOUP_ADDRESS_FAMILY_IS_VALID (h->h_addrtype) && SOUP_ADDRESS_FAMILY_DATA_SIZE (h->h_addrtype) == h->h_length) { - addr->priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (h->h_addrtype)); - SOUP_ADDRESS_SET_FAMILY (addr, h->h_addrtype); - SOUP_ADDRESS_SET_PORT (addr, htons (addr->priv->port)); - SOUP_ADDRESS_SET_DATA (addr, h->h_addr, h->h_length); + priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (h->h_addrtype)); + SOUP_ADDRESS_SET_FAMILY (priv, h->h_addrtype); + SOUP_ADDRESS_SET_PORT (priv, htons (priv->port)); + SOUP_ADDRESS_SET_DATA (priv, h->h_addr, h->h_length); } soup_dns_free_hostent (h); - if (addr->priv->name && addr->priv->sockaddr) + if (priv->name && priv->sockaddr) return SOUP_STATUS_OK; else return SOUP_STATUS_CANT_RESOLVE; @@ -363,20 +369,21 @@ static gboolean timeout_check_lookup (gpointer user_data) { SoupAddress *addr = user_data; + SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); guint status; - if (addr->priv->name && addr->priv->sockaddr) { - addr->priv->timeout_id = 0; + if (priv->name && priv->sockaddr) { + priv->timeout_id = 0; g_signal_emit (addr, signals[DNS_RESULT], 0, SOUP_STATUS_OK); return FALSE; } - if (!soup_dns_entry_check_lookup (addr->priv->lookup)) + if (!soup_dns_entry_check_lookup (priv->lookup)) return TRUE; - status = update_address_from_entry (addr, addr->priv->lookup); - addr->priv->lookup = NULL; - addr->priv->timeout_id = 0; + status = update_address_from_entry (addr, priv->lookup); + priv->lookup = NULL; + priv->timeout_id = 0; g_signal_emit (addr, signals[DNS_RESULT], 0, status); return FALSE; @@ -399,26 +406,27 @@ soup_address_resolve_async (SoupAddress *addr, SoupAddressCallback callback, gpointer user_data) { + SoupAddressPrivate *priv; + g_return_if_fail (SOUP_IS_ADDRESS (addr)); + priv = SOUP_ADDRESS_GET_PRIVATE (addr); if (callback) { soup_signal_connect_once (addr, "dns_result", G_CALLBACK (callback), user_data); } - if (addr->priv->timeout_id) + if (priv->timeout_id) return; - if (!addr->priv->sockaddr) { - addr->priv->lookup = - soup_dns_entry_from_name (addr->priv->name); - } else if (!addr->priv->name) { - addr->priv->lookup = - soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (addr), - SOUP_ADDRESS_GET_FAMILY (addr)); + if (!priv->sockaddr) { + priv->lookup = soup_dns_entry_from_name (priv->name); + } else if (!priv->name) { + priv->lookup = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (priv), + SOUP_ADDRESS_GET_FAMILY (priv)); } - addr->priv->timeout_id = g_timeout_add (100, timeout_check_lookup, addr); + priv->timeout_id = g_timeout_add (100, timeout_check_lookup, addr); } /** @@ -434,14 +442,16 @@ guint soup_address_resolve_sync (SoupAddress *addr) { SoupDNSEntry *entry; + SoupAddressPrivate *priv; g_return_val_if_fail (SOUP_IS_ADDRESS (addr), SOUP_STATUS_MALFORMED); + priv = SOUP_ADDRESS_GET_PRIVATE (addr); - if (addr->priv->name) - entry = soup_dns_entry_from_name (addr->priv->name); + if (priv->name) + entry = soup_dns_entry_from_name (priv->name); else { - entry = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (addr), - SOUP_ADDRESS_GET_FAMILY (addr)); + entry = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (priv), + SOUP_ADDRESS_GET_FAMILY (priv)); } return update_address_from_entry (addr, entry); diff --git a/libsoup/soup-address.h b/libsoup/soup-address.h index 24b08a3..c1140e2 100644 --- a/libsoup/soup-address.h +++ b/libsoup/soup-address.h @@ -18,12 +18,9 @@ #define SOUP_IS_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_ADDRESS)) #define SOUP_ADDRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_ADDRESS, SoupAddressClass)) -typedef struct SoupAddressPrivate SoupAddressPrivate; - struct SoupAddress { GObject parent; - SoupAddressPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-auth-basic.c b/libsoup/soup-auth-basic.c index 68755aa..f91acd0 100644 --- a/libsoup/soup-auth-basic.c +++ b/libsoup/soup-auth-basic.c @@ -24,39 +24,36 @@ static void authenticate (SoupAuth *auth, const char *username, const char *pass static gboolean is_authenticated (SoupAuth *auth); static char *get_authorization (SoupAuth *auth, SoupMessage *msg); -struct SoupAuthBasicPrivate { +typedef struct { char *realm, *token; -}; +} SoupAuthBasicPrivate; +#define SOUP_AUTH_BASIC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicPrivate)) -#define PARENT_TYPE SOUP_TYPE_AUTH -static SoupAuthClass *parent_class; +G_DEFINE_TYPE (SoupAuthBasic, soup_auth_basic, SOUP_TYPE_AUTH) static void -init (GObject *object) +soup_auth_basic_init (SoupAuthBasic *basic) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (object); - - basic->priv = g_new0 (SoupAuthBasicPrivate, 1); } static void finalize (GObject *object) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (object); + SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (object); - g_free (basic->priv->realm); - g_free (basic->priv->token); - g_free (basic->priv); + g_free (priv->realm); + g_free (priv->token); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_auth_basic_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_auth_basic_class_init (SoupAuthBasicClass *auth_basic_class) { - SoupAuthClass *auth_class = SOUP_AUTH_CLASS (object_class); + SoupAuthClass *auth_class = SOUP_AUTH_CLASS (auth_basic_class); + GObjectClass *object_class = G_OBJECT_CLASS (auth_basic_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (auth_basic_class, sizeof (SoupAuthBasicPrivate)); auth_class->scheme_name = "Basic"; @@ -70,13 +67,11 @@ class_init (GObjectClass *object_class) object_class->finalize = finalize; } -SOUP_MAKE_TYPE (soup_auth_basic, SoupAuthBasic, class_init, init, PARENT_TYPE) - static void construct (SoupAuth *auth, const char *header) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth); + SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth); GHashTable *tokens; header += sizeof ("Basic"); @@ -85,7 +80,7 @@ construct (SoupAuth *auth, const char *header) if (!tokens) return; - basic->priv->realm = soup_header_param_copy_token (tokens, "realm"); + priv->realm = soup_header_param_copy_token (tokens, "realm"); soup_header_param_destroy_hash (tokens); } @@ -107,15 +102,13 @@ get_protection_space (SoupAuth *auth, const SoupUri *source_uri) static const char * get_realm (SoupAuth *auth) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth); - - return basic->priv->realm; + return SOUP_AUTH_BASIC_GET_PRIVATE (auth)->realm; } static void authenticate (SoupAuth *auth, const char *username, const char *password) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth); + SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth); char *user_pass; int len; @@ -125,7 +118,7 @@ authenticate (SoupAuth *auth, const char *username, const char *password) user_pass = g_strdup_printf ("%s:%s", username, password); len = strlen (user_pass); - basic->priv->token = soup_base64_encode (user_pass, len); + priv->token = soup_base64_encode (user_pass, len); memset (user_pass, 0, len); g_free (user_pass); @@ -134,15 +127,13 @@ authenticate (SoupAuth *auth, const char *username, const char *password) static gboolean is_authenticated (SoupAuth *auth) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth); - - return basic->priv->token != NULL; + return SOUP_AUTH_BASIC_GET_PRIVATE (auth)->token != NULL; } static char * get_authorization (SoupAuth *auth, SoupMessage *msg) { - SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth); + SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth); - return g_strdup_printf ("Basic %s", basic->priv->token); + return g_strdup_printf ("Basic %s", priv->token); } diff --git a/libsoup/soup-auth-basic.h b/libsoup/soup-auth-basic.h index a0c0956..f6b7e2d 100644 --- a/libsoup/soup-auth-basic.h +++ b/libsoup/soup-auth-basic.h @@ -15,12 +15,9 @@ #define SOUP_IS_AUTH_BASIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_BASIC)) #define SOUP_AUTH_BASIC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicClass)) -typedef struct SoupAuthBasicPrivate SoupAuthBasicPrivate; - typedef struct { SoupAuth parent; - SoupAuthBasicPrivate *priv; } SoupAuthBasic; typedef struct { diff --git a/libsoup/soup-auth-digest.c b/libsoup/soup-auth-digest.c index a125d12..e54c262 100644 --- a/libsoup/soup-auth-digest.c +++ b/libsoup/soup-auth-digest.c @@ -39,7 +39,7 @@ typedef enum { ALGORITHM_MD5_SESS = 1 << 1 } AlgorithmType; -struct SoupAuthDigestPrivate { +typedef struct { char *user; guchar hex_a1[33]; @@ -54,46 +54,42 @@ struct SoupAuthDigestPrivate { char *cnonce; int nc; QOPType qop; -}; +} SoupAuthDigestPrivate; +#define SOUP_AUTH_DIGEST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestPrivate)) -#define PARENT_TYPE SOUP_TYPE_AUTH -static SoupAuthClass *parent_class; +G_DEFINE_TYPE (SoupAuthDigest, soup_auth_digest, SOUP_TYPE_AUTH) static void -init (GObject *object) +soup_auth_digest_init (SoupAuthDigest *digest) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (object); - - digest->priv = g_new0 (SoupAuthDigestPrivate, 1); } static void finalize (GObject *object) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (object); - - if (digest->priv->user) - g_free (digest->priv->user); - if (digest->priv->realm) - g_free (digest->priv->realm); - if (digest->priv->nonce) - g_free (digest->priv->nonce); - if (digest->priv->domain) - g_free (digest->priv->domain); - if (digest->priv->cnonce) - g_free (digest->priv->cnonce); - - g_free (digest->priv); - - G_OBJECT_CLASS (parent_class)->finalize (object); + SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (object); + + if (priv->user) + g_free (priv->user); + if (priv->realm) + g_free (priv->realm); + if (priv->nonce) + g_free (priv->nonce); + if (priv->domain) + g_free (priv->domain); + if (priv->cnonce) + g_free (priv->cnonce); + + G_OBJECT_CLASS (soup_auth_digest_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_auth_digest_class_init (SoupAuthDigestClass *auth_digest_class) { - SoupAuthClass *auth_class = SOUP_AUTH_CLASS (object_class); + SoupAuthClass *auth_class = SOUP_AUTH_CLASS (auth_digest_class); + GObjectClass *object_class = G_OBJECT_CLASS (auth_digest_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (auth_digest_class, sizeof (SoupAuthDigestPrivate)); auth_class->scheme_name = "Digest"; @@ -107,8 +103,6 @@ class_init (GObjectClass *object_class) object_class->finalize = finalize; } -SOUP_MAKE_TYPE (soup_auth_digest, SoupAuthDigest, class_init, init, PARENT_TYPE) - typedef struct { char *name; guint type; @@ -155,7 +149,7 @@ decode_algorithm (const char *name) static void construct (SoupAuth *auth, const char *header) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth); + SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth); GHashTable *tokens; char *tmp, *ptr; @@ -165,13 +159,13 @@ construct (SoupAuth *auth, const char *header) if (!tokens) return; - digest->priv->nc = 1; + priv->nc = 1; /* We're just going to do qop=auth for now */ - digest->priv->qop = QOP_AUTH; + priv->qop = QOP_AUTH; - digest->priv->realm = soup_header_param_copy_token (tokens, "realm"); - digest->priv->domain = soup_header_param_copy_token (tokens, "domain"); - digest->priv->nonce = soup_header_param_copy_token (tokens, "nonce"); + priv->realm = soup_header_param_copy_token (tokens, "realm"); + priv->domain = soup_header_param_copy_token (tokens, "domain"); + priv->nonce = soup_header_param_copy_token (tokens, "nonce"); tmp = soup_header_param_copy_token (tokens, "qop"); ptr = tmp; @@ -181,7 +175,7 @@ construct (SoupAuth *auth, const char *header) token = soup_header_param_decode_token ((char **)&ptr); if (token) - digest->priv->qop_options |= decode_qop (token); + priv->qop_options |= decode_qop (token); g_free (token); if (*ptr == ',') @@ -190,7 +184,7 @@ construct (SoupAuth *auth, const char *header) g_free (tmp); tmp = soup_header_param_copy_token (tokens, "algorithm"); - digest->priv->algorithm = decode_algorithm (tmp); + priv->algorithm = decode_algorithm (tmp); g_free (tmp); soup_header_param_destroy_hash (tokens); @@ -199,19 +193,19 @@ construct (SoupAuth *auth, const char *header) static GSList * get_protection_space (SoupAuth *auth, const SoupUri *source_uri) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth); + SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth); GSList *space = NULL; SoupUri *uri; char *domain, *d, *lasts, *dir, *slash; - if (!digest->priv->domain || !*digest->priv->domain) { + if (!priv->domain || !*priv->domain) { /* If no domain directive, the protection space is the * whole server. */ return g_slist_prepend (NULL, g_strdup ("")); } - domain = g_strdup (digest->priv->domain); + domain = g_strdup (priv->domain); for (d = strtok_r (domain, " ", &lasts); d; d = strtok_r (NULL, " ", &lasts)) { if (*d == '/') dir = g_strdup (d); @@ -243,9 +237,7 @@ get_protection_space (SoupAuth *auth, const SoupUri *source_uri) static const char * get_realm (SoupAuth *auth) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth); - - return digest->priv->realm; + return SOUP_AUTH_DIGEST_GET_PRIVATE (auth)->realm; } static void @@ -261,7 +253,7 @@ digest_hex (guchar *digest, guchar hex[33]) static void authenticate (SoupAuth *auth, const char *username, const char *password) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth); + SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth); SoupMD5Context ctx; guchar d[16]; char *bgen; @@ -269,13 +261,13 @@ authenticate (SoupAuth *auth, const char *username, const char *password) g_return_if_fail (username != NULL); bgen = g_strdup_printf ("%p:%lu:%lu", - auth, - (unsigned long) getpid (), - (unsigned long) time (0)); - digest->priv->cnonce = soup_base64_encode (bgen, strlen (bgen)); + auth, + (unsigned long) getpid (), + (unsigned long) time (0)); + priv->cnonce = soup_base64_encode (bgen, strlen (bgen)); g_free (bgen); - digest->priv->user = g_strdup (username); + priv->user = g_strdup (username); /* compute A1 */ soup_md5_init (&ctx); @@ -283,43 +275,41 @@ authenticate (SoupAuth *auth, const char *username, const char *password) soup_md5_update (&ctx, username, strlen (username)); soup_md5_update (&ctx, ":", 1); - if (digest->priv->realm) { - soup_md5_update (&ctx, digest->priv->realm, - strlen (digest->priv->realm)); + if (priv->realm) { + soup_md5_update (&ctx, priv->realm, + strlen (priv->realm)); } soup_md5_update (&ctx, ":", 1); if (password) soup_md5_update (&ctx, password, strlen (password)); - if (digest->priv->algorithm == ALGORITHM_MD5_SESS) { + if (priv->algorithm == ALGORITHM_MD5_SESS) { soup_md5_final (&ctx, d); soup_md5_init (&ctx); soup_md5_update (&ctx, d, 16); soup_md5_update (&ctx, ":", 1); - soup_md5_update (&ctx, digest->priv->nonce, - strlen (digest->priv->nonce)); + soup_md5_update (&ctx, priv->nonce, + strlen (priv->nonce)); soup_md5_update (&ctx, ":", 1); - soup_md5_update (&ctx, digest->priv->cnonce, - strlen (digest->priv->cnonce)); + soup_md5_update (&ctx, priv->cnonce, + strlen (priv->cnonce)); } /* hexify A1 */ soup_md5_final (&ctx, d); - digest_hex (d, digest->priv->hex_a1); + digest_hex (d, priv->hex_a1); } static gboolean is_authenticated (SoupAuth *auth) { - SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth); - - return digest->priv->cnonce != NULL; + return SOUP_AUTH_DIGEST_GET_PRIVATE (auth)->cnonce != NULL; } static char * -compute_response (SoupAuthDigest *digest, SoupMessage *msg) +compute_response (SoupAuthDigestPrivate *priv, SoupMessage *msg) { guchar hex_a2[33], o[33]; guchar d[16]; @@ -339,7 +329,7 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg) g_free (url); - if (digest->priv->qop == QOP_AUTH_INT) { + if (priv->qop == QOP_AUTH_INT) { /* FIXME: Actually implement. Ugh. */ soup_md5_update (&md5, ":", 1); soup_md5_update (&md5, "00000000000000000000000000000000", 32); @@ -351,27 +341,27 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg) /* compute KD */ soup_md5_init (&md5); - soup_md5_update (&md5, digest->priv->hex_a1, 32); + soup_md5_update (&md5, priv->hex_a1, 32); soup_md5_update (&md5, ":", 1); - soup_md5_update (&md5, digest->priv->nonce, - strlen (digest->priv->nonce)); + soup_md5_update (&md5, priv->nonce, + strlen (priv->nonce)); soup_md5_update (&md5, ":", 1); - if (digest->priv->qop) { + if (priv->qop) { char *tmp; - tmp = g_strdup_printf ("%.8x", digest->priv->nc); + tmp = g_strdup_printf ("%.8x", priv->nc); soup_md5_update (&md5, tmp, strlen (tmp)); g_free (tmp); soup_md5_update (&md5, ":", 1); - soup_md5_update (&md5, digest->priv->cnonce, - strlen (digest->priv->cnonce)); + soup_md5_update (&md5, priv->cnonce, + strlen (priv->cnonce)); soup_md5_update (&md5, ":", 1); - if (digest->priv->qop == QOP_AUTH) + if (priv->qop == QOP_AUTH) tmp = "auth"; - else if (digest->priv->qop == QOP_AUTH_INT) + else if (priv->qop == QOP_AUTH_INT) tmp = "auth-int"; else g_assert_not_reached (); @@ -391,7 +381,7 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg) static char * get_authorization (SoupAuth *auth, SoupMessage *msg) { - SoupAuthDigest *digest = (SoupAuthDigest *) auth; + SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth); char *response; char *qop = NULL; char *nc; @@ -403,35 +393,35 @@ get_authorization (SoupAuth *auth, SoupMessage *msg) g_return_val_if_fail (uri != NULL, NULL); url = soup_uri_to_string (uri, TRUE); - response = compute_response (digest, msg); + response = compute_response (priv, msg); - if (digest->priv->qop == QOP_AUTH) + if (priv->qop == QOP_AUTH) qop = "auth"; - else if (digest->priv->qop == QOP_AUTH_INT) + else if (priv->qop == QOP_AUTH_INT) qop = "auth-int"; else g_assert_not_reached (); - nc = g_strdup_printf ("%.8x", digest->priv->nc); + nc = g_strdup_printf ("%.8x", priv->nc); out = g_strdup_printf ( "Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", %s%s%s " "%s%s%s %s%s%s uri=\"%s\", response=\"%s\"", - digest->priv->user, - digest->priv->realm, - digest->priv->nonce, + priv->user, + priv->realm, + priv->nonce, - digest->priv->qop ? "cnonce=\"" : "", - digest->priv->qop ? digest->priv->cnonce : "", - digest->priv->qop ? "\"," : "", + priv->qop ? "cnonce=\"" : "", + priv->qop ? priv->cnonce : "", + priv->qop ? "\"," : "", - digest->priv->qop ? "nc=" : "", - digest->priv->qop ? nc : "", - digest->priv->qop ? "," : "", + priv->qop ? "nc=" : "", + priv->qop ? nc : "", + priv->qop ? "," : "", - digest->priv->qop ? "qop=" : "", - digest->priv->qop ? qop : "", - digest->priv->qop ? "," : "", + priv->qop ? "qop=" : "", + priv->qop ? qop : "", + priv->qop ? "," : "", url, response); @@ -440,7 +430,7 @@ get_authorization (SoupAuth *auth, SoupMessage *msg) g_free (url); g_free (nc); - digest->priv->nc++; + priv->nc++; return out; } diff --git a/libsoup/soup-auth-digest.h b/libsoup/soup-auth-digest.h index 3b8e072..b8bf8fa 100644 --- a/libsoup/soup-auth-digest.h +++ b/libsoup/soup-auth-digest.h @@ -15,12 +15,9 @@ #define SOUP_IS_AUTH_DIGEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_DIGEST)) #define SOUP_AUTH_DIGEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestClass)) -typedef struct SoupAuthDigestPrivate SoupAuthDigestPrivate; - typedef struct { SoupAuth parent; - SoupAuthDigestPrivate *priv; } SoupAuthDigest; typedef struct { diff --git a/libsoup/soup-auth.c b/libsoup/soup-auth.c index ba80a2f..fdc9f7d 100644 --- a/libsoup/soup-auth.c +++ b/libsoup/soup-auth.c @@ -15,17 +15,17 @@ #include "soup-auth-basic.h" #include "soup-auth-digest.h" -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupAuth, soup_auth, G_TYPE_OBJECT) static void -class_init (GObjectClass *object_class) +soup_auth_class_init (SoupAuthClass *auth_class) { - parent_class = g_type_class_ref (PARENT_TYPE); } -SOUP_MAKE_TYPE (soup_auth, SoupAuth, class_init, NULL, PARENT_TYPE) - +static void +soup_auth_init (SoupAuth *auth) +{ +} typedef struct { const char *scheme; diff --git a/libsoup/soup-connection-ntlm.c b/libsoup/soup-connection-ntlm.c index 66eacd2..5cc1eaa 100644 --- a/libsoup/soup-connection-ntlm.c +++ b/libsoup/soup-connection-ntlm.c @@ -27,14 +27,14 @@ typedef enum { SOUP_CONNECTION_NTLM_FAILED } SoupConnectionNTLMState; -struct SoupConnectionNTLMPrivate { +typedef struct { char *user; guchar nt_hash[21], lm_hash[21]; SoupConnectionNTLMState state; -}; +} SoupConnectionNTLMPrivate; +#define SOUP_CONNECTION_NTLM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMPrivate)) -#define PARENT_TYPE SOUP_TYPE_CONNECTION -static SoupConnectionClass *parent_class; +G_DEFINE_TYPE (SoupConnectionNTLM, soup_connection_ntlm, SOUP_TYPE_CONNECTION) static char *soup_ntlm_request (void); static gboolean soup_ntlm_parse_challenge (const char *challenge, @@ -47,58 +47,52 @@ static char *soup_ntlm_response (const char *nonce, const char *domain); static void -init (GObject *object) +soup_connection_ntlm_init (SoupConnectionNTLM *ntlm) { - SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (object); - - ntlm->priv = g_new0 (SoupConnectionNTLMPrivate, 1); } static void finalize (GObject *object) { - SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (object); - - g_free (ntlm->priv->user); - memset (ntlm->priv->nt_hash, 0, sizeof (ntlm->priv->nt_hash)); - memset (ntlm->priv->lm_hash, 0, sizeof (ntlm->priv->lm_hash)); + SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (object); - g_free (ntlm->priv); + g_free (priv->user); + memset (priv->nt_hash, 0, sizeof (priv->nt_hash)); + memset (priv->lm_hash, 0, sizeof (priv->lm_hash)); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_connection_ntlm_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_connection_ntlm_class_init (SoupConnectionNTLMClass *connection_ntlm_class) { - SoupConnectionClass *connection_class = - SOUP_CONNECTION_CLASS (object_class); + SoupConnectionClass *connection_class = SOUP_CONNECTION_CLASS (connection_ntlm_class); + GObjectClass *object_class = G_OBJECT_CLASS (connection_ntlm_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (connection_ntlm_class, sizeof (SoupConnectionNTLMPrivate)); connection_class->send_request = send_request; object_class->finalize = finalize; } -SOUP_MAKE_TYPE (soup_connection_ntlm, SoupConnectionNTLM, class_init, init, PARENT_TYPE) - static void ntlm_authorize_pre (SoupMessage *msg, gpointer user_data) { SoupConnectionNTLM *ntlm = user_data; + SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (ntlm); const GSList *headers; const char *val; char *nonce, *header; char *username, *domain_username = NULL, *password = NULL; char *slash, *domain; - if (ntlm->priv->state > SOUP_CONNECTION_NTLM_SENT_REQUEST) { + if (priv->state > SOUP_CONNECTION_NTLM_SENT_REQUEST) { /* We already authenticated, but then got another 401. * That means "permission denied", so don't try to * authenticate again. */ - ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED; + priv->state = SOUP_CONNECTION_NTLM_FAILED; goto done; } @@ -111,12 +105,12 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data) headers = headers->next; } if (!headers) { - ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED; + priv->state = SOUP_CONNECTION_NTLM_FAILED; goto done; } if (!soup_ntlm_parse_challenge (val, &nonce, &domain)) { - ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED; + priv->state = SOUP_CONNECTION_NTLM_FAILED; goto done; } @@ -147,7 +141,7 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data) soup_message_add_header (msg->request_headers, "Authorization", header); g_free (header); - ntlm->priv->state = SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE; + priv->state = SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE; done: /* Remove the WWW-Authenticate headers so the session won't try @@ -159,37 +153,35 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data) static void ntlm_authorize_post (SoupMessage *msg, gpointer conn) { - SoupConnectionNTLM *ntlm = conn; + SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (conn); - if (ntlm->priv->state == SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE && + if (priv->state == SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE && soup_message_get_header (msg->request_headers, "Authorization")) { /* We just added the last Auth header, so restart it. */ - ntlm->priv->state = SOUP_CONNECTION_NTLM_SENT_RESPONSE; + priv->state = SOUP_CONNECTION_NTLM_SENT_RESPONSE; soup_message_restarted (msg); soup_connection_send_request (conn, msg); } } static void -ntlm_cleanup_msg (SoupMessage *msg, gpointer user_data) +ntlm_cleanup_msg (SoupMessage *msg, gpointer conn) { - SoupConnectionNTLM *ntlm = user_data; - /* Do this when the message is restarted, in case it's * restarted on a different connection. */ soup_message_remove_handler (msg, SOUP_HANDLER_PRE_BODY, - ntlm_authorize_pre, ntlm); + ntlm_authorize_pre, conn); soup_message_remove_handler (msg, SOUP_HANDLER_POST_BODY, - ntlm_authorize_post, ntlm); + ntlm_authorize_post, conn); } void send_request (SoupConnection *conn, SoupMessage *req) { - SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (conn); + SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (conn); - if (ntlm->priv->state == SOUP_CONNECTION_NTLM_NEW) { + if (priv->state == SOUP_CONNECTION_NTLM_NEW) { char *header = soup_ntlm_request (); soup_message_remove_header (req->request_headers, @@ -197,7 +189,7 @@ send_request (SoupConnection *conn, SoupMessage *req) soup_message_add_header (req->request_headers, "Authorization", header); g_free (header); - ntlm->priv->state = SOUP_CONNECTION_NTLM_SENT_REQUEST; + priv->state = SOUP_CONNECTION_NTLM_SENT_REQUEST; } soup_message_add_status_code_handler (req, SOUP_STATUS_UNAUTHORIZED, @@ -209,11 +201,11 @@ send_request (SoupConnection *conn, SoupMessage *req) ntlm_authorize_post, conn); g_signal_connect (req, "restarted", - G_CALLBACK (ntlm_cleanup_msg), ntlm); + G_CALLBACK (ntlm_cleanup_msg), conn); g_signal_connect (req, "finished", - G_CALLBACK (ntlm_cleanup_msg), ntlm); + G_CALLBACK (ntlm_cleanup_msg), conn); - SOUP_CONNECTION_CLASS (parent_class)->send_request (conn, req); + SOUP_CONNECTION_CLASS (soup_connection_ntlm_parent_class)->send_request (conn, req); } diff --git a/libsoup/soup-connection-ntlm.h b/libsoup/soup-connection-ntlm.h index 8d0a242..b9a2b5c 100644 --- a/libsoup/soup-connection-ntlm.h +++ b/libsoup/soup-connection-ntlm.h @@ -15,12 +15,9 @@ #define SOUP_IS_CONNECTION_NTLM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_CONNECTION_NTLM)) #define SOUP_CONNECTION_NTLM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMClass)) -typedef struct SoupConnectionNTLMPrivate SoupConnectionNTLMPrivate; - typedef struct { SoupConnection parent; - SoupConnectionNTLMPrivate *priv; } SoupConnectionNTLM; typedef struct { diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c index 17676f9..0e88568 100644 --- a/libsoup/soup-connection.c +++ b/libsoup/soup-connection.c @@ -31,7 +31,7 @@ #include "soup-ssl.h" #include "soup-uri.h" -struct SoupConnectionPrivate { +typedef struct { SoupSocket *socket; /* proxy_uri is the URI of the proxy server we are connected @@ -48,10 +48,10 @@ struct SoupConnectionPrivate { SoupMessage *cur_req; time_t last_used; gboolean connected, in_use; -}; +} SoupConnectionPrivate; +#define SOUP_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_CONNECTION, SoupConnectionPrivate)) -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupConnection, soup_connection, G_TYPE_OBJECT) enum { CONNECT_RESULT, @@ -64,14 +64,14 @@ enum { static guint signals[LAST_SIGNAL] = { 0 }; enum { - PROP_0, + PROP_0, - PROP_ORIGIN_URI, - PROP_PROXY_URI, - PROP_SSL_CREDS, - PROP_MESSAGE_FILTER, + PROP_ORIGIN_URI, + PROP_PROXY_URI, + PROP_SSL_CREDS, + PROP_MESSAGE_FILTER, - LAST_PROP + LAST_PROP }; static void set_property (GObject *object, guint prop_id, @@ -83,50 +83,45 @@ static void request_done (SoupMessage *req, gpointer user_data); static void send_request (SoupConnection *conn, SoupMessage *req); static void -init (GObject *object) +soup_connection_init (SoupConnection *conn) { - SoupConnection *conn = SOUP_CONNECTION (object); - - conn->priv = g_new0 (SoupConnectionPrivate, 1); } static void finalize (GObject *object) { - SoupConnection *conn = SOUP_CONNECTION (object); - - if (conn->priv->proxy_uri) - soup_uri_free (conn->priv->proxy_uri); - if (conn->priv->origin_uri) - soup_uri_free (conn->priv->origin_uri); + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object); - if (conn->priv->filter) - g_object_unref (conn->priv->filter); + if (priv->proxy_uri) + soup_uri_free (priv->proxy_uri); + if (priv->origin_uri) + soup_uri_free (priv->origin_uri); - g_free (conn->priv); + if (priv->filter) + g_object_unref (priv->filter); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_connection_parent_class)->finalize (object); } static void dispose (GObject *object) { SoupConnection *conn = SOUP_CONNECTION (object); + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object); - if (conn->priv->cur_req) - request_done (conn->priv->cur_req, conn); + if (priv->cur_req) + request_done (priv->cur_req, conn); soup_connection_disconnect (conn); - G_OBJECT_CLASS (parent_class)->dispose (object); + G_OBJECT_CLASS (soup_connection_parent_class)->dispose (object); } static void -class_init (GObjectClass *object_class) +soup_connection_class_init (SoupConnectionClass *connection_class) { - SoupConnectionClass *connection_class = - SOUP_CONNECTION_CLASS (object_class); + GObjectClass *object_class = G_OBJECT_CLASS (connection_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (connection_class, sizeof (SoupConnectionPrivate)); /* virtual method definition */ connection_class->send_request = send_request; @@ -209,8 +204,6 @@ class_init (GObjectClass *object_class) G_PARAM_READWRITE)); } -SOUP_MAKE_TYPE (soup_connection, SoupConnection, class_init, init, PARENT_TYPE) - /** * soup_connection_new: @@ -247,29 +240,29 @@ static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { - SoupConnection *conn = SOUP_CONNECTION (object); + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object); gpointer pval; switch (prop_id) { case PROP_ORIGIN_URI: pval = g_value_get_pointer (value); - conn->priv->origin_uri = pval ? soup_uri_copy (pval) : NULL; - if (!conn->priv->proxy_uri) - conn->priv->conn_uri = conn->priv->origin_uri; + priv->origin_uri = pval ? soup_uri_copy (pval) : NULL; + if (!priv->proxy_uri) + priv->conn_uri = priv->origin_uri; break; case PROP_PROXY_URI: pval = g_value_get_pointer (value); - conn->priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL; - if (conn->priv->proxy_uri) - conn->priv->conn_uri = conn->priv->proxy_uri; + priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL; + if (priv->proxy_uri) + priv->conn_uri = priv->proxy_uri; else - conn->priv->conn_uri = conn->priv->origin_uri; + priv->conn_uri = priv->origin_uri; break; case PROP_SSL_CREDS: - conn->priv->ssl_creds = g_value_get_pointer (value); + priv->ssl_creds = g_value_get_pointer (value); break; case PROP_MESSAGE_FILTER: - conn->priv->filter = g_object_ref (g_value_get_pointer (value)); + priv->filter = g_object_ref (g_value_get_pointer (value)); break; default: break; @@ -280,23 +273,23 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { - SoupConnection *conn = SOUP_CONNECTION (object); + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object); switch (prop_id) { case PROP_ORIGIN_URI: - g_value_set_pointer (value, conn->priv->origin_uri ? - soup_uri_copy (conn->priv->origin_uri) : + g_value_set_pointer (value, priv->origin_uri ? + soup_uri_copy (priv->origin_uri) : NULL); break; case PROP_PROXY_URI: - g_value_set_pointer (value, conn->priv->proxy_uri ? - soup_uri_copy (conn->priv->proxy_uri) : + g_value_set_pointer (value, priv->proxy_uri ? + soup_uri_copy (priv->proxy_uri) : NULL); case PROP_SSL_CREDS: - g_value_set_pointer (value, conn->priv->ssl_creds); + g_value_set_pointer (value, priv->ssl_creds); break; case PROP_MESSAGE_FILTER: - g_value_set_pointer (value, g_object_ref (conn->priv->filter)); + g_value_set_pointer (value, g_object_ref (priv->filter)); break; default: break; @@ -304,26 +297,25 @@ get_property (GObject *object, guint prop_id, } static void -set_current_request (SoupConnection *conn, SoupMessage *req) +set_current_request (SoupConnectionPrivate *priv, SoupMessage *req) { - g_return_if_fail (conn->priv->cur_req == NULL); + g_return_if_fail (priv->cur_req == NULL); req->status = SOUP_MESSAGE_STATUS_RUNNING; - conn->priv->cur_req = req; - conn->priv->in_use = TRUE; - g_object_add_weak_pointer (G_OBJECT (req), - (gpointer *)conn->priv->cur_req); + priv->cur_req = req; + priv->in_use = TRUE; + g_object_add_weak_pointer (G_OBJECT (req), (gpointer *)priv->cur_req); } static void -clear_current_request (SoupConnection *conn) +clear_current_request (SoupConnectionPrivate *priv) { - if (conn->priv->cur_req) { - g_object_remove_weak_pointer (G_OBJECT (conn->priv->cur_req), - (gpointer *)conn->priv->cur_req); - conn->priv->cur_req = NULL; + if (priv->cur_req) { + g_object_remove_weak_pointer (G_OBJECT (priv->cur_req), + (gpointer *)priv->cur_req); + priv->cur_req = NULL; } - conn->priv->in_use = FALSE; + priv->in_use = FALSE; } static void @@ -333,9 +325,9 @@ socket_disconnected (SoupSocket *sock, gpointer conn) } static inline guint -proxified_status (SoupConnection *conn, guint status) +proxified_status (SoupConnectionPrivate *priv, guint status) { - if (!conn->priv->proxy_uri) + if (!priv->proxy_uri) return status; if (status == SOUP_STATUS_CANT_RESOLVE) @@ -350,14 +342,15 @@ static void tunnel_connect_finished (SoupMessage *msg, gpointer user_data) { SoupConnection *conn = user_data; + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn); guint status = msg->status_code; - clear_current_request (conn); + clear_current_request (priv); if (SOUP_STATUS_IS_SUCCESSFUL (status)) { - if (soup_socket_start_proxy_ssl (conn->priv->socket, - conn->priv->origin_uri->host)) - conn->priv->connected = TRUE; + if (soup_socket_start_proxy_ssl (priv->socket, + priv->origin_uri->host)) + priv->connected = TRUE; else status = SOUP_STATUS_SSL_FAILED; } else if (SOUP_STATUS_IS_REDIRECTION (status)) { @@ -366,7 +359,7 @@ tunnel_connect_finished (SoupMessage *msg, gpointer user_data) } g_signal_emit (conn, signals[CONNECT_RESULT], 0, - proxified_status (conn, status)); + proxified_status (priv, status)); g_object_unref (msg); } @@ -405,11 +398,12 @@ static void socket_connect_result (SoupSocket *sock, guint status, gpointer user_data) { SoupConnection *conn = user_data; + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) goto done; - if (conn->priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) { + if (priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) { if (!soup_socket_start_ssl (sock)) { status = SOUP_STATUS_SSL_FAILED; goto done; @@ -417,13 +411,13 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data) } /* See if we need to tunnel */ - if (conn->priv->proxy_uri && - conn->priv->origin_uri && - conn->priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) { + if (priv->proxy_uri && + priv->origin_uri && + priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) { SoupMessage *connect_msg; connect_msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, - conn->priv->origin_uri); + priv->origin_uri); g_signal_connect (connect_msg, "restarted", G_CALLBACK (tunnel_connect_restarted), conn); @@ -434,11 +428,11 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data) return; } - conn->priv->connected = TRUE; + priv->connected = TRUE; done: g_signal_emit (conn, signals[CONNECT_RESULT], 0, - proxified_status (conn, status)); + proxified_status (priv, status)); } /** @@ -454,20 +448,23 @@ soup_connection_connect_async (SoupConnection *conn, SoupConnectionCallback callback, gpointer user_data) { + SoupConnectionPrivate *priv; + g_return_if_fail (SOUP_IS_CONNECTION (conn)); - g_return_if_fail (conn->priv->socket == NULL); + priv = SOUP_CONNECTION_GET_PRIVATE (conn); + g_return_if_fail (priv->socket == NULL); if (callback) { soup_signal_connect_once (conn, "connect_result", G_CALLBACK (callback), user_data); } - conn->priv->socket = - soup_socket_client_new_async (conn->priv->conn_uri->host, - conn->priv->conn_uri->port, - conn->priv->ssl_creds, + priv->socket = + soup_socket_client_new_async (priv->conn_uri->host, + priv->conn_uri->port, + priv->ssl_creds, socket_connect_result, conn); - g_signal_connect (conn->priv->socket, "disconnected", + g_signal_connect (priv->socket, "disconnected", G_CALLBACK (socket_disconnected), conn); } @@ -482,38 +479,40 @@ soup_connection_connect_async (SoupConnection *conn, guint soup_connection_connect_sync (SoupConnection *conn) { + SoupConnectionPrivate *priv; guint status; g_return_val_if_fail (SOUP_IS_CONNECTION (conn), SOUP_STATUS_MALFORMED); - g_return_val_if_fail (conn->priv->socket == NULL, SOUP_STATUS_MALFORMED); + priv = SOUP_CONNECTION_GET_PRIVATE (conn); + g_return_val_if_fail (priv->socket == NULL, SOUP_STATUS_MALFORMED); - conn->priv->socket = - soup_socket_client_new_sync (conn->priv->conn_uri->host, - conn->priv->conn_uri->port, - conn->priv->ssl_creds, + priv->socket = + soup_socket_client_new_sync (priv->conn_uri->host, + priv->conn_uri->port, + priv->ssl_creds, &status); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) goto fail; - g_signal_connect (conn->priv->socket, "disconnected", + g_signal_connect (priv->socket, "disconnected", G_CALLBACK (socket_disconnected), conn); - if (conn->priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) { - if (!soup_socket_start_ssl (conn->priv->socket)) { + if (priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) { + if (!soup_socket_start_ssl (priv->socket)) { status = SOUP_STATUS_SSL_FAILED; goto fail; } } /* See if we need to tunnel */ - if (conn->priv->proxy_uri && - conn->priv->origin_uri && - conn->priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) { + if (priv->proxy_uri && + priv->origin_uri && + priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) { SoupMessage *connect_msg; connect_msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, - conn->priv->origin_uri); + priv->origin_uri); soup_connection_send_request (conn, connect_msg); status = connect_msg->status_code; @@ -531,16 +530,16 @@ soup_connection_connect_sync (SoupConnection *conn) } if (SOUP_STATUS_IS_SUCCESSFUL (status)) - conn->priv->connected = TRUE; + priv->connected = TRUE; else { fail: - if (conn->priv->socket) { - g_object_unref (conn->priv->socket); - conn->priv->socket = NULL; + if (priv->socket) { + g_object_unref (priv->socket); + priv->socket = NULL; } } - status = proxified_status (conn, status); + status = proxified_status (priv, status); g_signal_emit (conn, signals[CONNECT_RESULT], 0, status); return status; } @@ -556,33 +555,36 @@ soup_connection_connect_sync (SoupConnection *conn) void soup_connection_disconnect (SoupConnection *conn) { + SoupConnectionPrivate *priv; + g_return_if_fail (SOUP_IS_CONNECTION (conn)); + priv = SOUP_CONNECTION_GET_PRIVATE (conn); - if (!conn->priv->socket) + if (!priv->socket) return; - g_signal_handlers_disconnect_by_func (conn->priv->socket, + g_signal_handlers_disconnect_by_func (priv->socket, socket_disconnected, conn); - soup_socket_disconnect (conn->priv->socket); - g_object_unref (conn->priv->socket); - conn->priv->socket = NULL; + soup_socket_disconnect (priv->socket); + g_object_unref (priv->socket); + priv->socket = NULL; /* Don't emit "disconnected" if we aren't yet connected */ - if (!conn->priv->connected) + if (!priv->connected) return; - conn->priv->connected = FALSE; + priv->connected = FALSE; g_signal_emit (conn, signals[DISCONNECTED], 0); - if (!conn->priv->cur_req || - conn->priv->cur_req->status_code != SOUP_STATUS_IO_ERROR) + if (!priv->cur_req || + priv->cur_req->status_code != SOUP_STATUS_IO_ERROR) return; /* There was a message queued on this connection, but the * socket was closed while it was being sent. */ - if (conn->priv->last_used != 0) { + if (priv->last_used != 0) { /* If last_used is not 0, then that means at least one * message was successfully sent on this connection * before, and so the most likely cause of the @@ -596,11 +598,11 @@ soup_connection_disconnect (SoupConnection *conn) * all we need to do to get the message requeued in * this case is to change its status. */ - conn->priv->cur_req->status = SOUP_MESSAGE_STATUS_QUEUED; + priv->cur_req->status = SOUP_MESSAGE_STATUS_QUEUED; return; } - /* If conn->priv->last_used is 0, then that means this was the + /* If priv->last_used is 0, then that means this was the * first message to be sent on this connection, so the error * probably means that there's some network or server problem, * so we let the IO_ERROR be returned to the caller. @@ -630,7 +632,7 @@ soup_connection_is_in_use (SoupConnection *conn) { g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE); - return conn->priv->in_use; + return SOUP_CONNECTION_GET_PRIVATE (conn)->in_use; } /** @@ -647,7 +649,7 @@ soup_connection_last_used (SoupConnection *conn) { g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE); - return conn->priv->last_used; + return SOUP_CONNECTION_GET_PRIVATE (conn)->last_used; } static void @@ -661,9 +663,10 @@ static void request_done (SoupMessage *req, gpointer user_data) { SoupConnection *conn = user_data; + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn); - clear_current_request (conn); - conn->priv->last_used = time (NULL); + clear_current_request (priv); + priv->last_used = time (NULL); if (!soup_message_is_keepalive (req)) soup_connection_disconnect (conn); @@ -676,22 +679,24 @@ request_done (SoupMessage *req, gpointer user_data) static void send_request (SoupConnection *conn, SoupMessage *req) { + SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn); + g_object_ref (conn); - if (req != conn->priv->cur_req) { - set_current_request (conn, req); + if (req != priv->cur_req) { + set_current_request (priv, req); g_signal_connect (req, "restarted", G_CALLBACK (request_restarted), conn); g_signal_connect (req, "finished", G_CALLBACK (request_done), conn); - if (conn->priv->filter) - soup_message_filter_setup_message (conn->priv->filter, req); + if (priv->filter) + soup_message_filter_setup_message (priv->filter, req); } - soup_message_send_request (req, conn->priv->socket, - conn->priv->proxy_uri != NULL); + soup_message_send_request (req, priv->socket, + priv->proxy_uri != NULL); } /** @@ -707,7 +712,7 @@ soup_connection_send_request (SoupConnection *conn, SoupMessage *req) { g_return_if_fail (SOUP_IS_CONNECTION (conn)); g_return_if_fail (SOUP_IS_MESSAGE (req)); - g_return_if_fail (conn->priv->socket != NULL); + g_return_if_fail (SOUP_CONNECTION_GET_PRIVATE (conn)->socket != NULL); SOUP_CONNECTION_GET_CLASS (conn)->send_request (conn, req); } @@ -726,7 +731,7 @@ soup_connection_reserve (SoupConnection *conn) { g_return_if_fail (SOUP_IS_CONNECTION (conn)); - conn->priv->in_use = TRUE; + SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = TRUE; } /** @@ -742,7 +747,7 @@ soup_connection_release (SoupConnection *conn) { g_return_if_fail (SOUP_IS_CONNECTION (conn)); - conn->priv->in_use = FALSE; + SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = FALSE; } /** diff --git a/libsoup/soup-connection.h b/libsoup/soup-connection.h index 959bceb..f3c056c 100644 --- a/libsoup/soup-connection.h +++ b/libsoup/soup-connection.h @@ -17,12 +17,9 @@ #define SOUP_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_CONNECTION)) #define SOUP_CONNECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION, SoupConnectionClass)) -typedef struct SoupConnectionPrivate SoupConnectionPrivate; - struct SoupConnection { GObject parent; - SoupConnectionPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-message-client-io.c b/libsoup/soup-message-client-io.c index fdc6429..1cad9f6 100644 --- a/libsoup/soup-message-client-io.c +++ b/libsoup/soup-message-client-io.c @@ -24,6 +24,7 @@ parse_response_headers (SoupMessage *req, guint *content_len, gpointer user_data) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req); const char *length, *enc; SoupHttpVersion version; GHashTable *resp_hdrs; @@ -36,8 +37,8 @@ parse_response_headers (SoupMessage *req, (char **) &req->reason_phrase)) return SOUP_STATUS_MALFORMED; - if (version < req->priv->http_version) - req->priv->http_version = version; + if (version < priv->http_version) + priv->http_version = version; meth_id = soup_method_get_id (req->method); resp_hdrs = req->response_headers; @@ -107,6 +108,7 @@ get_request_headers (SoupMessage *req, GString *header, SoupTransferEncoding *encoding, gpointer user_data) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req); gboolean proxy = GPOINTER_TO_UINT (user_data); const SoupUri *uri = soup_message_get_uri (req); const char *expect; @@ -122,7 +124,7 @@ get_request_headers (SoupMessage *req, GString *header, uri_string = soup_uri_to_string (uri, !proxy); } - if (req->priv->http_version == SOUP_HTTP_1_0) { + if (priv->http_version == SOUP_HTTP_1_0) { g_string_append_printf (header, "%s %s HTTP/1.0\r\n", req->method, uri_string); } else { @@ -154,7 +156,7 @@ get_request_headers (SoupMessage *req, GString *header, expect = soup_message_get_header (req->request_headers, "Expect"); if (expect && !strcmp (expect, "100-continue")) - req->priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE; + priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE; } /** diff --git a/libsoup/soup-message-handlers.c b/libsoup/soup-message-handlers.c index 89ccbf8..20553e3 100644 --- a/libsoup/soup-message-handlers.c +++ b/libsoup/soup-message-handlers.c @@ -72,15 +72,16 @@ run_handler (SoupMessage *msg, void soup_message_run_handlers (SoupMessage *msg, SoupHandlerPhase invoke_phase) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); GSList *copy, *list; g_return_if_fail (SOUP_IS_MESSAGE (msg)); /* Jump through hoops to deal with callbacks that modify the list. */ - copy = g_slist_copy (msg->priv->content_handlers); + copy = g_slist_copy (priv->content_handlers); for (list = copy; list; list = list->next) { - if (!g_slist_find (msg->priv->content_handlers, list->data)) + if (!g_slist_find (priv->content_handlers, list->data)) continue; run_handler (msg, invoke_phase, list->data); @@ -101,6 +102,7 @@ add_handler (SoupMessage *msg, guint status_code, SoupStatusClass status_class) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); SoupHandlerData *data; data = g_new0 (SoupHandlerData, 1); @@ -123,8 +125,8 @@ add_handler (SoupMessage *msg, break; } - msg->priv->content_handlers = - g_slist_append (msg->priv->content_handlers, data); + priv->content_handlers = + g_slist_append (priv->content_handlers, data); } /** @@ -244,7 +246,9 @@ soup_message_remove_handler (SoupMessage *msg, SoupMessageCallbackFn handler_cb, gpointer user_data) { - GSList *iter = msg->priv->content_handlers; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + + GSList *iter = priv->content_handlers; while (iter) { SoupHandlerData *data = iter->data; @@ -252,8 +256,8 @@ soup_message_remove_handler (SoupMessage *msg, if (data->handler_cb == handler_cb && data->user_data == user_data && data->phase == phase) { - msg->priv->content_handlers = - g_slist_remove (msg->priv->content_handlers, + priv->content_handlers = + g_slist_remove (priv->content_handlers, data); g_free (data); break; diff --git a/libsoup/soup-message-io.c b/libsoup/soup-message-io.c index 7350378..b551a27 100644 --- a/libsoup/soup-message-io.c +++ b/libsoup/soup-message-io.c @@ -64,15 +64,16 @@ typedef struct { */ #define dummy_to_make_emacs_happy { #define SOUP_MESSAGE_IO_PREPARE_FOR_CALLBACK { gboolean cancelled; g_object_ref (msg); -#define SOUP_MESSAGE_IO_RETURN_IF_CANCELLED_OR_PAUSED cancelled = (msg->priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return; } -#define SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED(val) cancelled = (msg->priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return val; } +#define SOUP_MESSAGE_IO_RETURN_IF_CANCELLED_OR_PAUSED cancelled = (priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return; } +#define SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED(val) cancelled = (priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return val; } #define RESPONSE_BLOCK_SIZE 8192 static void io_cleanup (SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; if (!io) return; @@ -89,7 +90,7 @@ io_cleanup (SoupMessage *msg) g_string_free (io->write_buf, TRUE); g_free (io); - msg->priv->io_data = NULL; + priv->io_data = NULL; } /** @@ -102,7 +103,8 @@ io_cleanup (SoupMessage *msg) void soup_message_io_stop (SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; if (!io) return; @@ -145,7 +147,8 @@ soup_message_io_finished (SoupMessage *msg) static void io_error (SoupSocket *sock, SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; /* Closing the connection to signify EOF is sometimes ok */ if (io->read_state == SOUP_MESSAGE_IO_STATE_BODY && @@ -173,7 +176,8 @@ io_error (SoupSocket *sock, SoupMessage *msg) static gboolean read_metadata (SoupMessage *msg, const char *boundary) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; SoupSocketIOStatus status; char read_buf[RESPONSE_BLOCK_SIZE]; guint boundary_len = strlen (boundary); @@ -206,7 +210,8 @@ read_metadata (SoupMessage *msg, const char *boundary) static gboolean read_body_chunk (SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; SoupSocketIOStatus status; char read_buf[RESPONSE_BLOCK_SIZE]; guint len = sizeof (read_buf); @@ -259,7 +264,8 @@ read_body_chunk (SoupMessage *msg) static gboolean write_data (SoupMessage *msg, const char *data, guint len) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; SoupSocketIOStatus status; gsize nwrote; @@ -326,7 +332,8 @@ static void io_read (SoupSocket *sock, SoupMessage *msg); static void io_write (SoupSocket *sock, SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; write_more: switch (io->write_state) { @@ -366,7 +373,7 @@ io_write (SoupSocket *sock, SoupMessage *msg) */ } } else if (io->mode == SOUP_MESSAGE_IO_CLIENT && - msg->priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE) { + priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE) { /* Need to wait for the Continue response */ io->write_state = SOUP_MESSAGE_IO_STATE_BLOCKING; io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS; @@ -499,7 +506,8 @@ io_write (SoupSocket *sock, SoupMessage *msg) static void io_read (SoupSocket *sock, SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; guint status; read_more: @@ -550,7 +558,7 @@ io_read (SoupSocket *sock, SoupMessage *msg) io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS; } } else if (io->mode == SOUP_MESSAGE_IO_SERVER && - (msg->priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE)) { + (priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE)) { /* The client requested a Continue response. */ io->write_state = SOUP_MESSAGE_IO_STATE_HEADERS; io->read_state = SOUP_MESSAGE_IO_STATE_BLOCKING; @@ -661,6 +669,7 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode, SoupMessageParseHeadersFn parse_headers_cb, gpointer user_data) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); SoupMessageIOData *io; io = g_new0 (SoupMessageIOData, 1); @@ -674,7 +683,7 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode, io->write_encoding = SOUP_TRANSFER_UNKNOWN; io->read_meta_buf = g_byte_array_new (); - if (!(msg->priv->msg_flags & SOUP_MESSAGE_OVERWRITE_CHUNKS)) + if (!(priv->msg_flags & SOUP_MESSAGE_OVERWRITE_CHUNKS)) io->read_buf = g_byte_array_new (); io->write_buf = g_string_new (NULL); @@ -688,9 +697,9 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode, io->read_state = SOUP_MESSAGE_IO_STATE_NOT_STARTED; io->write_state = SOUP_MESSAGE_IO_STATE_NOT_STARTED; - if (msg->priv->io_data) + if (priv->io_data) io_cleanup (msg); - msg->priv->io_data = io; + priv->io_data = io; return io; } @@ -763,7 +772,8 @@ soup_message_io_server (SoupMessage *msg, SoupSocket *sock, void soup_message_io_pause (SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; g_return_if_fail (io != NULL); @@ -786,7 +796,8 @@ soup_message_io_pause (SoupMessage *msg) void soup_message_io_unpause (SoupMessage *msg) { - SoupMessageIOData *io = msg->priv->io_data; + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); + SoupMessageIOData *io = priv->io_data; g_return_if_fail (io != NULL); diff --git a/libsoup/soup-message-private.h b/libsoup/soup-message-private.h index c17bc78..e1168f6 100644 --- a/libsoup/soup-message-private.h +++ b/libsoup/soup-message-private.h @@ -8,7 +8,7 @@ #include -struct SoupMessagePrivate { +typedef struct { gpointer io_data; guint msg_flags; @@ -20,7 +20,8 @@ struct SoupMessagePrivate { SoupHttpVersion http_version; SoupUri *uri; -}; +} SoupMessagePrivate; +#define SOUP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_MESSAGE, SoupMessagePrivate)) void soup_message_run_handlers (SoupMessage *msg, SoupHandlerPhase phase); diff --git a/libsoup/soup-message-server-io.c b/libsoup/soup-message-server-io.c index 96d8dc8..1462cec 100644 --- a/libsoup/soup-message-server-io.c +++ b/libsoup/soup-message-server-io.c @@ -25,6 +25,7 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len, SoupTransferEncoding *encoding, guint *content_len, gpointer sock) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); SoupUri *uri; char *req_path = NULL, *url; const char *expect, *length, *enc, *req_host; @@ -34,12 +35,12 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len, msg->request_headers, (char **) &msg->method, &req_path, - &msg->priv->http_version)) + &priv->http_version)) return SOUP_STATUS_BAD_REQUEST; expect = soup_message_get_header (msg->request_headers, "Expect"); if (expect && !strcmp (expect, "100-continue")) - msg->priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE; + priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE; /* Handle request body encoding */ length = soup_message_get_header (msg->request_headers, @@ -90,7 +91,7 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len, soup_server_get_protocol (server) == SOUP_PROTOCOL_HTTPS ? "https" : "http", req_host, soup_server_get_port (server), req_path); - } else if (msg->priv->http_version == SOUP_HTTP_1_0) { + } else if (priv->http_version == SOUP_HTTP_1_0) { /* No Host header, no AbsoluteUri */ SoupAddress *addr = soup_socket_get_local_address (sock); const char *host = soup_address_get_physical (addr); diff --git a/libsoup/soup-message.c b/libsoup/soup-message.c index 2960f74..50afe93 100644 --- a/libsoup/soup-message.c +++ b/libsoup/soup-message.c @@ -14,8 +14,7 @@ #include "soup-misc.h" #include "soup-uri.h" -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupMessage, soup_message, G_TYPE_OBJECT) enum { WROTE_INFORMATIONAL, @@ -45,12 +44,8 @@ static void finished (SoupMessage *req); static void free_chunks (SoupMessage *msg); static void -init (GObject *object) +soup_message_init (SoupMessage *msg) { - SoupMessage *msg = SOUP_MESSAGE (object); - - msg->priv = g_new0 (SoupMessagePrivate, 1); - msg->status = SOUP_MESSAGE_STATUS_IDLE; msg->request_headers = g_hash_table_new (soup_str_case_hash, @@ -59,18 +54,19 @@ init (GObject *object) msg->response_headers = g_hash_table_new (soup_str_case_hash, soup_str_case_equal); - msg->priv->http_version = SOUP_HTTP_1_1; + SOUP_MESSAGE_GET_PRIVATE (msg)->http_version = SOUP_HTTP_1_1; } static void finalize (GObject *object) { SoupMessage *msg = SOUP_MESSAGE (object); + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); soup_message_io_stop (msg); - if (msg->priv->uri) - soup_uri_free (msg->priv->uri); + if (priv->uri) + soup_uri_free (priv->uri); if (msg->request.owner == SOUP_BUFFER_SYSTEM_OWNED) g_free (msg->request.body); @@ -84,22 +80,20 @@ finalize (GObject *object) soup_message_clear_headers (msg->response_headers); g_hash_table_destroy (msg->response_headers); - g_slist_foreach (msg->priv->content_handlers, (GFunc) g_free, NULL); - g_slist_free (msg->priv->content_handlers); + g_slist_foreach (priv->content_handlers, (GFunc) g_free, NULL); + g_slist_free (priv->content_handlers); g_free ((char *) msg->reason_phrase); - g_free (msg->priv); - - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_message_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_message_class_init (SoupMessageClass *message_class) { - SoupMessageClass *message_class = SOUP_MESSAGE_CLASS (object_class); + GObjectClass *object_class = G_OBJECT_CLASS (message_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (message_class, sizeof (SoupMessagePrivate)); /* virtual method definition */ message_class->wrote_body = wrote_body; @@ -197,8 +191,6 @@ class_init (GObjectClass *object_class) G_TYPE_NONE, 0); } -SOUP_MAKE_TYPE (soup_message, SoupMessage, class_init, init, PARENT_TYPE) - /** * soup_message_new: @@ -227,7 +219,7 @@ soup_message_new (const char *method, const char *uri_string) msg = g_object_new (SOUP_TYPE_MESSAGE, NULL); msg->method = method ? method : SOUP_METHOD_GET; - msg->priv->uri = uri; + SOUP_MESSAGE_GET_PRIVATE (msg)->uri = uri; return msg; } @@ -248,7 +240,7 @@ soup_message_new_from_uri (const char *method, const SoupUri *uri) msg = g_object_new (SOUP_TYPE_MESSAGE, NULL); msg->method = method ? method : SOUP_METHOD_GET; - msg->priv->uri = soup_uri_copy (uri); + SOUP_MESSAGE_GET_PRIVATE (msg)->uri = soup_uri_copy (uri); return msg; } @@ -695,7 +687,7 @@ soup_message_set_flags (SoupMessage *msg, guint flags) { g_return_if_fail (SOUP_IS_MESSAGE (msg)); - msg->priv->msg_flags = flags; + SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags = flags; } /** @@ -711,7 +703,7 @@ soup_message_get_flags (SoupMessage *msg) { g_return_val_if_fail (SOUP_IS_MESSAGE (msg), 0); - return msg->priv->msg_flags; + return SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags; } /** @@ -728,7 +720,7 @@ soup_message_set_http_version (SoupMessage *msg, SoupHttpVersion version) { g_return_if_fail (SOUP_IS_MESSAGE (msg)); - msg->priv->http_version = version; + SOUP_MESSAGE_GET_PRIVATE (msg)->http_version = version; } /** @@ -745,7 +737,7 @@ soup_message_get_http_version (SoupMessage *msg) { g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_HTTP_1_0); - return msg->priv->http_version; + return SOUP_MESSAGE_GET_PRIVATE (msg)->http_version; } /** @@ -769,7 +761,7 @@ soup_message_is_keepalive (SoupMessage *msg) soup_method_get_id (msg->method) == SOUP_METHOD_ID_CONNECT) return TRUE; - if (msg->priv->http_version == SOUP_HTTP_1_0) { + if (SOUP_MESSAGE_GET_PRIVATE (msg)->http_version == SOUP_HTTP_1_0) { /* Only persistent if the client requested keepalive * and the server agreed. */ @@ -804,17 +796,20 @@ soup_message_is_keepalive (SoupMessage *msg) void soup_message_set_uri (SoupMessage *msg, const SoupUri *new_uri) { + SoupMessagePrivate *priv; + g_return_if_fail (SOUP_IS_MESSAGE (msg)); + priv = SOUP_MESSAGE_GET_PRIVATE (msg); - if (msg->priv->uri && new_uri) { - if (strcmp (msg->priv->uri->host, new_uri->host) != 0) + if (priv->uri && new_uri) { + if (strcmp (priv->uri->host, new_uri->host) != 0) soup_message_io_stop (msg); } else if (!new_uri) soup_message_io_stop (msg); - if (msg->priv->uri) - soup_uri_free (msg->priv->uri); - msg->priv->uri = soup_uri_copy (new_uri); + if (priv->uri) + soup_uri_free (priv->uri); + priv->uri = soup_uri_copy (new_uri); } /** @@ -830,7 +825,7 @@ soup_message_get_uri (SoupMessage *msg) { g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL); - return msg->priv->uri; + return SOUP_MESSAGE_GET_PRIVATE (msg)->uri; } /** @@ -893,9 +888,11 @@ soup_message_add_chunk (SoupMessage *msg, const char *body, guint length) { + SoupMessagePrivate *priv; SoupDataBuffer *chunk; g_return_if_fail (SOUP_IS_MESSAGE (msg)); + priv = SOUP_MESSAGE_GET_PRIVATE (msg); g_return_if_fail (body != NULL || length == 0); chunk = g_new0 (SoupDataBuffer, 1); @@ -908,11 +905,11 @@ soup_message_add_chunk (SoupMessage *msg, } chunk->length = length; - if (msg->priv->chunks) { - g_slist_append (msg->priv->last_chunk, chunk); - msg->priv->last_chunk = msg->priv->last_chunk->next; + if (priv->chunks) { + g_slist_append (priv->last_chunk, chunk); + priv->last_chunk = priv->last_chunk->next; } else { - msg->priv->chunks = msg->priv->last_chunk = + priv->chunks = priv->last_chunk = g_slist_append (NULL, chunk); } } @@ -944,17 +941,19 @@ soup_message_add_final_chunk (SoupMessage *msg) SoupDataBuffer * soup_message_pop_chunk (SoupMessage *msg) { + SoupMessagePrivate *priv; SoupDataBuffer *chunk; g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL); + priv = SOUP_MESSAGE_GET_PRIVATE (msg); - if (!msg->priv->chunks) + if (!priv->chunks) return NULL; - chunk = msg->priv->chunks->data; - msg->priv->chunks = g_slist_remove (msg->priv->chunks, chunk); - if (!msg->priv->chunks) - msg->priv->last_chunk = NULL; + chunk = priv->chunks->data; + priv->chunks = g_slist_remove (priv->chunks, chunk); + if (!priv->chunks) + priv->last_chunk = NULL; return chunk; } @@ -962,10 +961,11 @@ soup_message_pop_chunk (SoupMessage *msg) static void free_chunks (SoupMessage *msg) { + SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg); SoupDataBuffer *chunk; GSList *ch; - for (ch = msg->priv->chunks; ch; ch = ch->next) { + for (ch = priv->chunks; ch; ch = ch->next) { chunk = ch->data; if (chunk->owner == SOUP_BUFFER_SYSTEM_OWNED) @@ -973,6 +973,6 @@ free_chunks (SoupMessage *msg) g_free (chunk); } - g_slist_free (msg->priv->chunks); - msg->priv->chunks = msg->priv->last_chunk = NULL; + g_slist_free (priv->chunks); + priv->chunks = priv->last_chunk = NULL; } diff --git a/libsoup/soup-message.h b/libsoup/soup-message.h index af2b28d..e47da72 100644 --- a/libsoup/soup-message.h +++ b/libsoup/soup-message.h @@ -16,8 +16,6 @@ #define SOUP_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE)) #define SOUP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_MESSAGE, SoupMessageClass)) -typedef struct SoupMessagePrivate SoupMessagePrivate; - typedef enum { SOUP_MESSAGE_STATUS_IDLE, SOUP_MESSAGE_STATUS_QUEUED, @@ -49,8 +47,6 @@ typedef struct { struct SoupMessage { GObject parent; - SoupMessagePrivate *priv; - const char *method; guint status_code; diff --git a/libsoup/soup-server-message.c b/libsoup/soup-server-message.c index 24bb959..0de7510 100644 --- a/libsoup/soup-server-message.c +++ b/libsoup/soup-server-message.c @@ -17,24 +17,21 @@ #include "soup-server-message.h" #include "soup-server.h" -struct SoupServerMessagePrivate { +typedef struct { SoupServer *server; SoupTransferEncoding encoding; gboolean started; gboolean finished; -}; +} SoupServerMessagePrivate; +#define SOUP_SERVER_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessagePrivate)) -#define PARENT_TYPE SOUP_TYPE_MESSAGE -static SoupMessageClass *parent_class; +G_DEFINE_TYPE (SoupServerMessage, soup_server_message, SOUP_TYPE_MESSAGE) static void -init (GObject *object) +soup_server_message_init (SoupServerMessage *smsg) { - SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (object); - - smsg->priv = g_new0 (SoupServerMessagePrivate, 1); } static void @@ -45,36 +42,32 @@ finalize (GObject *object) /* FIXME */ g_free ((char *) ((SoupMessage *)smsg)->method); - g_free (smsg->priv); - - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_server_message_parent_class)->finalize (object); } static void dispose (GObject *object) { - SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (object); + SoupServerMessagePrivate *priv = SOUP_SERVER_MESSAGE_GET_PRIVATE (object); - if (smsg->priv->server) - g_object_unref (smsg->priv->server); + if (priv->server) + g_object_unref (priv->server); - G_OBJECT_CLASS (parent_class)->dispose (object); + G_OBJECT_CLASS (soup_server_message_parent_class)->dispose (object); } - - static void -class_init (GObjectClass *object_class) +soup_server_message_class_init (SoupServerMessageClass *soup_server_message_class) { - parent_class = g_type_class_ref (PARENT_TYPE); + GObjectClass *object_class = G_OBJECT_CLASS (soup_server_message_class); + + g_type_class_add_private (soup_server_message_class, sizeof (SoupServerMessagePrivate)); /* virtual method override */ object_class->finalize = finalize; object_class->dispose = dispose; } -SOUP_MAKE_TYPE (soup_server_message, SoupServerMessage, class_init, init, PARENT_TYPE) - SoupServerMessage * soup_server_message_new (SoupServer *server) @@ -84,7 +77,7 @@ soup_server_message_new (SoupServer *server) g_return_val_if_fail (SOUP_IS_SERVER (server), NULL); smsg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL); - smsg->priv->server = g_object_ref (server); + SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->server = g_object_ref (server); return smsg; } @@ -94,7 +87,7 @@ soup_server_message_get_server (SoupServerMessage *smsg) { g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), NULL); - return smsg->priv->server; + return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->server; } void @@ -103,7 +96,7 @@ soup_server_message_set_encoding (SoupServerMessage *smsg, { g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg)); - smsg->priv->encoding = encoding; + SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->encoding = encoding; } SoupTransferEncoding @@ -111,7 +104,7 @@ soup_server_message_get_encoding (SoupServerMessage *smsg) { g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), SOUP_TRANSFER_UNKNOWN); - return smsg->priv->encoding; + return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->encoding; } void @@ -119,7 +112,7 @@ soup_server_message_start (SoupServerMessage *smsg) { g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg)); - smsg->priv->started = TRUE; + SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->started = TRUE; soup_message_io_unpause (SOUP_MESSAGE (smsg)); } @@ -129,16 +122,19 @@ soup_server_message_is_started (SoupServerMessage *smsg) { g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), TRUE); - return smsg->priv->started; + return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->started; } void soup_server_message_finish (SoupServerMessage *smsg) { + SoupServerMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg)); + priv = SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg); - smsg->priv->started = TRUE; - smsg->priv->finished = TRUE; + priv->started = TRUE; + priv->finished = TRUE; soup_message_io_unpause (SOUP_MESSAGE (smsg)); } @@ -148,5 +144,5 @@ soup_server_message_is_finished (SoupServerMessage *smsg) { g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), TRUE); - return smsg->priv->finished; + return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->finished; } diff --git a/libsoup/soup-server-message.h b/libsoup/soup-server-message.h index 349c2b7..201b43a 100644 --- a/libsoup/soup-server-message.h +++ b/libsoup/soup-server-message.h @@ -15,12 +15,9 @@ #define SOUP_IS_SERVER_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER_MESSAGE)) #define SOUP_SERVER_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessageClass)) -typedef struct SoupServerMessagePrivate SoupServerMessagePrivate; - struct SoupServerMessage { SoupMessage parent; - SoupServerMessagePrivate *priv; }; typedef struct { diff --git a/libsoup/soup-server.c b/libsoup/soup-server.c index e0738da..620266c 100644 --- a/libsoup/soup-server.c +++ b/libsoup/soup-server.c @@ -26,10 +26,9 @@ #include "soup-socket.h" #include "soup-ssl.h" -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupServer, soup_server, G_TYPE_OBJECT) -struct SoupServerPrivate { +typedef struct { SoupAddress *interface; guint port; @@ -43,17 +42,18 @@ struct SoupServerPrivate { GHashTable *handlers; /* KEY: path, VALUE: SoupServerHandler */ SoupServerHandler *default_handler; -}; +} SoupServerPrivate; +#define SOUP_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SERVER, SoupServerPrivate)) enum { - PROP_0, + PROP_0, - PROP_PORT, - PROP_INTERFACE, - PROP_SSL_CERT_FILE, - PROP_SSL_KEY_FILE, + PROP_PORT, + PROP_INTERFACE, + PROP_SSL_CERT_FILE, + PROP_SSL_KEY_FILE, - LAST_PROP + LAST_PROP }; static void set_property (GObject *object, guint prop_id, @@ -62,12 +62,11 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void -init (GObject *object) +soup_server_init (SoupServer *server) { - SoupServer *server = SOUP_SERVER (object); + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server); - server->priv = g_new0 (SoupServerPrivate, 1); - server->priv->handlers = g_hash_table_new (g_str_hash, g_str_equal); + priv->handlers = g_hash_table_new (g_str_hash, g_str_equal); } static void @@ -96,45 +95,45 @@ static void finalize (GObject *object) { SoupServer *server = SOUP_SERVER (object); + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server); - if (server->priv->interface) - g_object_unref (server->priv->interface); + if (priv->interface) + g_object_unref (priv->interface); - g_free (server->priv->ssl_cert_file); - g_free (server->priv->ssl_key_file); - if (server->priv->ssl_creds) - soup_ssl_free_server_credentials (server->priv->ssl_creds); + g_free (priv->ssl_cert_file); + g_free (priv->ssl_key_file); + if (priv->ssl_creds) + soup_ssl_free_server_credentials (priv->ssl_creds); - if (server->priv->listen_sock) - g_object_unref (server->priv->listen_sock); + if (priv->listen_sock) + g_object_unref (priv->listen_sock); - while (server->priv->client_socks) { - SoupSocket *sock = server->priv->client_socks->data; + while (priv->client_socks) { + SoupSocket *sock = priv->client_socks->data; soup_socket_disconnect (sock); - server->priv->client_socks = - g_slist_remove (server->priv->client_socks, sock); + priv->client_socks = + g_slist_remove (priv->client_socks, sock); } - if (server->priv->default_handler) - free_handler (server, server->priv->default_handler); + if (priv->default_handler) + free_handler (server, priv->default_handler); - g_hash_table_foreach (server->priv->handlers, - free_handler_foreach, server); - g_hash_table_destroy (server->priv->handlers); + g_hash_table_foreach (priv->handlers, free_handler_foreach, server); + g_hash_table_destroy (priv->handlers); - if (server->priv->loop) - g_main_loop_unref (server->priv->loop); + if (priv->loop) + g_main_loop_unref (priv->loop); - g_free (server->priv); - - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_server_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_server_class_init (SoupServerClass *server_class) { - parent_class = g_type_class_ref (PARENT_TYPE); + GObjectClass *object_class = G_OBJECT_CLASS (server_class); + + g_type_class_add_private (server_class, sizeof (SoupServerPrivate)); /* virtual method override */ object_class->finalize = finalize; @@ -159,44 +158,43 @@ class_init (GObjectClass *object_class) g_object_class_install_property ( object_class, PROP_SSL_CERT_FILE, g_param_spec_string (SOUP_SERVER_SSL_CERT_FILE, - "SSL certificate file", - "File containing server SSL certificate", - NULL, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + "SSL certificate file", + "File containing server SSL certificate", + NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property ( object_class, PROP_SSL_KEY_FILE, g_param_spec_string (SOUP_SERVER_SSL_KEY_FILE, - "SSL key file", - "File containing server SSL key", - NULL, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + "SSL key file", + "File containing server SSL key", + NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); } -SOUP_MAKE_TYPE (soup_server, SoupServer, class_init, init, PARENT_TYPE) static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { - SoupServer *server = SOUP_SERVER (object); + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (object); switch (prop_id) { case PROP_PORT: - server->priv->port = g_value_get_uint (value); + priv->port = g_value_get_uint (value); break; case PROP_INTERFACE: - if (server->priv->interface) - g_object_unref (server->priv->interface); - server->priv->interface = g_value_get_object (value); - if (server->priv->interface) - g_object_ref (server->priv->interface); + if (priv->interface) + g_object_unref (priv->interface); + priv->interface = g_value_get_object (value); + if (priv->interface) + g_object_ref (priv->interface); break; case PROP_SSL_CERT_FILE: - server->priv->ssl_cert_file = + priv->ssl_cert_file = g_strdup (g_value_get_string (value)); break; case PROP_SSL_KEY_FILE: - server->priv->ssl_key_file = + priv->ssl_key_file = g_strdup (g_value_get_string (value)); break; default: @@ -208,20 +206,20 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { - SoupServer *server = SOUP_SERVER (object); + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (object); switch (prop_id) { case PROP_PORT: - g_value_set_uint (value, server->priv->port); + g_value_set_uint (value, priv->port); break; case PROP_INTERFACE: - g_value_set_object (value, g_object_ref (server->priv->interface)); + g_value_set_object (value, g_object_ref (priv->interface)); break; case PROP_SSL_CERT_FILE: - g_value_set_string (value, g_strdup (server->priv->ssl_cert_file)); + g_value_set_string (value, g_strdup (priv->ssl_cert_file)); break; case PROP_SSL_KEY_FILE: - g_value_set_string (value, g_strdup (server->priv->ssl_key_file)); + g_value_set_string (value, g_strdup (priv->ssl_key_file)); break; default: break; @@ -232,6 +230,7 @@ SoupServer * soup_server_new (const char *optname1, ...) { SoupServer *server; + SoupServerPrivate *priv; va_list ap; va_start (ap, optname1); @@ -241,27 +240,29 @@ soup_server_new (const char *optname1, ...) if (!server) return NULL; - if (!server->priv->interface) { - server->priv->interface = + priv = SOUP_SERVER_GET_PRIVATE (server); + + if (!priv->interface) { + priv->interface = soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV4, - server->priv->port); + priv->port); } - if (server->priv->ssl_cert_file && server->priv->ssl_key_file) { - server->priv->ssl_creds = soup_ssl_get_server_credentials ( - server->priv->ssl_cert_file, - server->priv->ssl_key_file); - if (!server->priv->ssl_creds) { + if (priv->ssl_cert_file && priv->ssl_key_file) { + priv->ssl_creds = soup_ssl_get_server_credentials ( + priv->ssl_cert_file, + priv->ssl_key_file); + if (!priv->ssl_creds) { g_object_unref (server); return NULL; } } - server->priv->listen_sock = - soup_socket_server_new (server->priv->interface, - server->priv->ssl_creds, + priv->listen_sock = + soup_socket_server_new (priv->interface, + priv->ssl_creds, NULL, NULL); - if (!server->priv->listen_sock) { + if (!priv->listen_sock) { g_object_unref (server); return NULL; } @@ -269,11 +270,10 @@ soup_server_new (const char *optname1, ...) /* Re-resolve the interface address, in particular in case * the passed-in address had SOUP_ADDRESS_ANY_PORT. */ - g_object_unref (server->priv->interface); - server->priv->interface = - soup_socket_get_local_address (server->priv->listen_sock); - g_object_ref (server->priv->interface); - server->priv->port = soup_address_get_port (server->priv->interface); + g_object_unref (priv->interface); + priv->interface = soup_socket_get_local_address (priv->listen_sock); + g_object_ref (priv->interface); + priv->port = soup_address_get_port (priv->interface); return server; } @@ -283,15 +283,18 @@ soup_server_get_port (SoupServer *server) { g_return_val_if_fail (SOUP_IS_SERVER (server), 0); - return server->priv->port; + return SOUP_SERVER_GET_PRIVATE (server)->port; } SoupProtocol soup_server_get_protocol (SoupServer *server) { + SoupServerPrivate *priv; + g_return_val_if_fail (SOUP_IS_SERVER (server), 0); + priv = SOUP_SERVER_GET_PRIVATE (server); - if (server->priv->ssl_cert_file && server->priv->ssl_key_file) + if (priv->ssl_cert_file && priv->ssl_key_file) return SOUP_PROTOCOL_HTTPS; else return SOUP_PROTOCOL_HTTP; @@ -420,8 +423,9 @@ start_request (SoupServer *server, SoupSocket *server_sock) static void socket_disconnected (SoupSocket *sock, SoupServer *server) { - server->priv->client_socks = - g_slist_remove (server->priv->client_socks, sock); + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server); + + priv->client_socks = g_slist_remove (priv->client_socks, sock); g_signal_handlers_disconnect_by_func (sock, socket_disconnected, server); g_object_unref (sock); } @@ -430,10 +434,10 @@ static void new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data) { SoupServer *server = user_data; + SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server); g_object_ref (sock); - server->priv->client_socks = - g_slist_prepend (server->priv->client_socks, sock); + priv->client_socks = g_slist_prepend (priv->client_socks, sock); g_signal_connect (sock, "disconnected", G_CALLBACK (socket_disconnected), server); start_request (server, sock); @@ -442,17 +446,20 @@ new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data) void soup_server_run_async (SoupServer *server) { + SoupServerPrivate *priv; + g_return_if_fail (SOUP_IS_SERVER (server)); + priv = SOUP_SERVER_GET_PRIVATE (server); - if (!server->priv->listen_sock) { - if (server->priv->loop) { - g_main_loop_unref (server->priv->loop); - server->priv->loop = NULL; + if (!priv->listen_sock) { + if (priv->loop) { + g_main_loop_unref (priv->loop); + priv->loop = NULL; } return; } - g_signal_connect (server->priv->listen_sock, "new_connection", + g_signal_connect (priv->listen_sock, "new_connection", G_CALLBACK (new_connection), server); g_object_ref (server); @@ -463,23 +470,29 @@ soup_server_run_async (SoupServer *server) void soup_server_run (SoupServer *server) { + SoupServerPrivate *priv; + g_return_if_fail (SOUP_IS_SERVER (server)); + priv = SOUP_SERVER_GET_PRIVATE (server); - if (!server->priv->loop) { - server->priv->loop = g_main_loop_new (NULL, TRUE); + if (!priv->loop) { + priv->loop = g_main_loop_new (NULL, TRUE); soup_server_run_async (server); } - if (server->priv->loop) - g_main_loop_run (server->priv->loop); + if (priv->loop) + g_main_loop_run (priv->loop); } void soup_server_quit (SoupServer *server) { + SoupServerPrivate *priv; + g_return_if_fail (SOUP_IS_SERVER (server)); + priv = SOUP_SERVER_GET_PRIVATE (server); - g_main_loop_quit (server->priv->loop); + g_main_loop_quit (priv->loop); g_object_unref (server); } @@ -494,9 +507,13 @@ append_handler (gpointer key, gpointer value, gpointer user_data) GSList * soup_server_list_handlers (SoupServer *server) { + SoupServerPrivate *priv; GSList *ret = NULL; - g_hash_table_foreach (server->priv->handlers, append_handler, &ret); + g_return_val_if_fail (SOUP_IS_SERVER (server), NULL); + priv = SOUP_SERVER_GET_PRIVATE (server); + + g_hash_table_foreach (priv->handlers, append_handler, &ret); return ret; } @@ -504,13 +521,15 @@ soup_server_list_handlers (SoupServer *server) SoupServerHandler * soup_server_get_handler (SoupServer *server, const char *path) { + SoupServerPrivate *priv; char *mypath, *dir; SoupServerHandler *hand = NULL; g_return_val_if_fail (SOUP_IS_SERVER (server), NULL); + priv = SOUP_SERVER_GET_PRIVATE (server); - if (!path || !server->priv->handlers) - return server->priv->default_handler; + if (!path || !priv->handlers) + return priv->default_handler; mypath = g_strdup (path); @@ -520,7 +539,7 @@ soup_server_get_handler (SoupServer *server, const char *path) dir = mypath; do { - hand = g_hash_table_lookup (server->priv->handlers, mypath); + hand = g_hash_table_lookup (priv->handlers, mypath); if (hand) { g_free (mypath); return hand; @@ -532,7 +551,7 @@ soup_server_get_handler (SoupServer *server, const char *path) g_free (mypath); - return server->priv->default_handler; + return priv->default_handler; } SoupAddress * @@ -584,11 +603,13 @@ soup_server_add_handler (SoupServer *server, SoupServerUnregisterFn unregister, gpointer user_data) { + SoupServerPrivate *priv; SoupServerHandler *hand; SoupServerAuthContext *new_auth_ctx = NULL; g_return_if_fail (SOUP_IS_SERVER (server)); g_return_if_fail (callback != NULL); + priv = SOUP_SERVER_GET_PRIVATE (server); if (auth_ctx) new_auth_ctx = auth_context_copy (auth_ctx); @@ -602,31 +623,33 @@ soup_server_add_handler (SoupServer *server, if (path) { soup_server_remove_handler (server, path); - g_hash_table_insert (server->priv->handlers, hand->path, hand); + g_hash_table_insert (priv->handlers, hand->path, hand); } else { soup_server_remove_handler (server, NULL); - server->priv->default_handler = hand; + priv->default_handler = hand; } } void soup_server_remove_handler (SoupServer *server, const char *path) { + SoupServerPrivate *priv; SoupServerHandler *hand; g_return_if_fail (SOUP_IS_SERVER (server)); + priv = SOUP_SERVER_GET_PRIVATE (server); if (!path) { - if (server->priv->default_handler) { - free_handler (server, server->priv->default_handler); - server->priv->default_handler = NULL; + if (priv->default_handler) { + free_handler (server, priv->default_handler); + priv->default_handler = NULL; } return; } - hand = g_hash_table_lookup (server->priv->handlers, path); + hand = g_hash_table_lookup (priv->handlers, path); if (hand) { - g_hash_table_remove (server->priv->handlers, path); + g_hash_table_remove (priv->handlers, path); free_handler (server, hand); } } diff --git a/libsoup/soup-server.h b/libsoup/soup-server.h index 4c9adf6..c2f6061 100644 --- a/libsoup/soup-server.h +++ b/libsoup/soup-server.h @@ -17,12 +17,9 @@ #define SOUP_IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER)) #define SOUP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER, SoupServerClass)) -typedef struct SoupServerPrivate SoupServerPrivate; - struct SoupServer { GObject parent; - SoupServerPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-session-async.c b/libsoup/soup-session-async.c index 81a9d44..b35afec 100644 --- a/libsoup/soup-session-async.c +++ b/libsoup/soup-session-async.c @@ -12,10 +12,6 @@ #include "soup-session-async.h" #include "soup-connection.h" -struct SoupSessionAsyncPrivate { - int dummy; -}; - static gboolean run_queue (SoupSessionAsync *sa, gboolean try_pruning); static void queue_message (SoupSession *session, SoupMessage *req, @@ -23,41 +19,23 @@ static void queue_message (SoupSession *session, SoupMessage *req, gpointer user_data); static guint send_message (SoupSession *session, SoupMessage *req); -#define PARENT_TYPE SOUP_TYPE_SESSION -static SoupSessionClass *parent_class; +G_DEFINE_TYPE (SoupSessionAsync, soup_session_async, SOUP_TYPE_SESSION) static void -init (GObject *object) +soup_session_async_init (SoupSessionAsync *sa) { - SoupSessionAsync *sa = SOUP_SESSION_ASYNC (object); - - sa->priv = g_new0 (SoupSessionAsyncPrivate, 1); } static void -finalize (GObject *object) +soup_session_async_class_init (SoupSessionAsyncClass *soup_session_async_class) { - SoupSessionAsync *sa = SOUP_SESSION_ASYNC (object); - - g_free (sa->priv); - - G_OBJECT_CLASS (parent_class)->finalize (object); -} - -static void -class_init (GObjectClass *object_class) -{ - SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class); - - parent_class = g_type_class_ref (PARENT_TYPE); + SoupSessionClass *session_class = SOUP_SESSION_CLASS (soup_session_async_class); /* virtual method override */ session_class->queue_message = queue_message; session_class->send_message = send_message; - object_class->finalize = finalize; } -SOUP_MAKE_TYPE (soup_session_async, SoupSessionAsync, class_init, init, PARENT_TYPE) SoupSession * soup_session_async_new (void) @@ -205,8 +183,7 @@ queue_message (SoupSession *session, SoupMessage *req, g_signal_connect_after (req, "finished", G_CALLBACK (final_finished), sa); - SOUP_SESSION_CLASS (parent_class)->queue_message (session, req, - callback, user_data); + SOUP_SESSION_CLASS (soup_session_async_parent_class)->queue_message (session, req, callback, user_data); run_queue (sa, TRUE); } diff --git a/libsoup/soup-session-async.h b/libsoup/soup-session-async.h index 26f5fe7..2423809 100644 --- a/libsoup/soup-session-async.h +++ b/libsoup/soup-session-async.h @@ -16,12 +16,9 @@ #define SOUP_IS_SESSION_ASYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC)) #define SOUP_SESSION_ASYNC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass)) -typedef struct SoupSessionAsyncPrivate SoupSessionAsyncPrivate; - struct SoupSessionAsync { SoupSession parent; - SoupSessionAsyncPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-session-sync.c b/libsoup/soup-session-sync.c index 120f016..88e700a 100644 --- a/libsoup/soup-session-sync.c +++ b/libsoup/soup-session-sync.c @@ -12,10 +12,11 @@ #include "soup-session-sync.h" #include "soup-connection.h" -struct SoupSessionSyncPrivate { +typedef struct { GMutex *lock; GCond *cond; -}; +} SoupSessionSyncPrivate; +#define SOUP_SESSION_SYNC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncPrivate)) void queue_message (SoupSession *session, SoupMessage *msg, SoupMessageCallbackFn callback, @@ -23,37 +24,35 @@ void queue_message (SoupSession *session, SoupMessage *msg, static guint send_message (SoupSession *session, SoupMessage *msg); static void cancel_message (SoupSession *session, SoupMessage *msg); -#define PARENT_TYPE SOUP_TYPE_SESSION -static SoupSessionClass *parent_class; +G_DEFINE_TYPE (SoupSessionSync, soup_session_sync, SOUP_TYPE_SESSION) static void -init (GObject *object) +soup_session_sync_init (SoupSessionSync *ss) { - SoupSessionSync *ss = SOUP_SESSION_SYNC (object); + SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (ss); - ss->priv = g_new0 (SoupSessionSyncPrivate, 1); - ss->priv->lock = g_mutex_new (); - ss->priv->cond = g_cond_new (); + priv->lock = g_mutex_new (); + priv->cond = g_cond_new (); } static void finalize (GObject *object) { - SoupSessionSync *ss = SOUP_SESSION_SYNC (object); + SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (object); - g_mutex_free (ss->priv->lock); - g_cond_free (ss->priv->cond); - g_free (ss->priv); + g_mutex_free (priv->lock); + g_cond_free (priv->cond); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_session_sync_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_session_sync_class_init (SoupSessionSyncClass *session_sync_class) { - SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class); + GObjectClass *object_class = G_OBJECT_CLASS (session_sync_class); + SoupSessionClass *session_class = SOUP_SESSION_CLASS (session_sync_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (session_sync_class, sizeof (SoupSessionSyncPrivate)); /* virtual method override */ session_class->queue_message = queue_message; @@ -62,7 +61,6 @@ class_init (GObjectClass *object_class) object_class->finalize = finalize; } -SOUP_MAKE_TYPE (soup_session_sync, SoupSessionSync, class_init, init, PARENT_TYPE) SoupSession * soup_session_sync_new (void) @@ -96,12 +94,12 @@ queue_message (SoupSession *session, SoupMessage *msg, static SoupConnection * wait_for_connection (SoupSession *session, SoupMessage *msg) { - SoupSessionSync *ss = SOUP_SESSION_SYNC (session); + SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session); SoupConnection *conn; gboolean try_pruning = FALSE, is_new = FALSE; guint status; - g_mutex_lock (ss->priv->lock); + g_mutex_lock (priv->lock); try_again: conn = soup_session_get_connection (session, msg, @@ -127,7 +125,7 @@ wait_for_connection (SoupSession *session, SoupMessage *msg) } } - g_mutex_unlock (ss->priv->lock); + g_mutex_unlock (priv->lock); return conn; } @@ -135,11 +133,11 @@ wait_for_connection (SoupSession *session, SoupMessage *msg) goto try_again; /* Wait... */ - g_cond_wait (ss->priv->cond, ss->priv->lock); + g_cond_wait (priv->cond, priv->lock); /* See if something bad happened */ if (msg->status == SOUP_MESSAGE_STATUS_FINISHED) { - g_mutex_unlock (ss->priv->lock); + g_mutex_unlock (priv->lock); return NULL; } @@ -149,11 +147,10 @@ wait_for_connection (SoupSession *session, SoupMessage *msg) static guint send_message (SoupSession *session, SoupMessage *msg) { - SoupSessionSync *ss = SOUP_SESSION_SYNC (session); + SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session); SoupConnection *conn; - SOUP_SESSION_CLASS (parent_class)->queue_message (session, msg, - NULL, NULL); + SOUP_SESSION_CLASS (soup_session_sync_parent_class)->queue_message (session, msg, NULL, NULL); do { /* Get a connection */ @@ -162,7 +159,7 @@ send_message (SoupSession *session, SoupMessage *msg) return msg->status_code; soup_connection_send_request (conn, msg); - g_cond_broadcast (ss->priv->cond); + g_cond_broadcast (priv->cond); } while (msg->status != SOUP_MESSAGE_STATUS_FINISHED); return msg->status_code; @@ -171,9 +168,9 @@ send_message (SoupSession *session, SoupMessage *msg) static void cancel_message (SoupSession *session, SoupMessage *msg) { - SoupSessionSync *ss = SOUP_SESSION_SYNC (session); + SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session); - SOUP_SESSION_CLASS (parent_class)->cancel_message (session, msg); - g_cond_broadcast (ss->priv->cond); + SOUP_SESSION_CLASS (soup_session_sync_parent_class)->cancel_message (session, msg); + g_cond_broadcast (priv->cond); } diff --git a/libsoup/soup-session-sync.h b/libsoup/soup-session-sync.h index 8765279..b775de0 100644 --- a/libsoup/soup-session-sync.h +++ b/libsoup/soup-session-sync.h @@ -16,12 +16,9 @@ #define SOUP_IS_SESSION_SYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_SYNC)) #define SOUP_SESSION_SYNC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass)) -typedef struct SoupSessionSyncPrivate SoupSessionSyncPrivate; - struct SoupSessionSync { SoupSession parent; - SoupSessionSyncPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c index 7851156..a082096 100644 --- a/libsoup/soup-session.c +++ b/libsoup/soup-session.c @@ -33,7 +33,7 @@ typedef struct { GHashTable *auths; /* scheme:realm -> SoupAuth */ } SoupSessionHost; -struct SoupSessionPrivate { +typedef struct { SoupUri *proxy_uri; guint max_conns, max_conns_per_host; gboolean use_ntlm; @@ -54,11 +54,12 @@ struct SoupSessionPrivate { * Must not emit signals or destroy objects while holding it. */ GMutex *host_lock; -}; +} SoupSessionPrivate; +#define SOUP_SESSION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION, SoupSessionPrivate)) static guint host_uri_hash (gconstpointer key); static gboolean host_uri_equal (gconstpointer v1, gconstpointer v2); -static void free_host (SoupSessionHost *host, SoupSession *session); +static void free_host (SoupSessionHost *host); static void setup_message (SoupMessageFilter *filter, SoupMessage *msg); @@ -71,8 +72,11 @@ static void cancel_message (SoupSession *session, SoupMessage *msg); #define SOUP_SESSION_MAX_CONNS_DEFAULT 10 #define SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT 4 -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +static void filter_iface_init (SoupMessageFilterClass *filter_class); + +G_DEFINE_TYPE_EXTENDED (SoupSession, soup_session, G_TYPE_OBJECT, 0, + G_IMPLEMENT_INTERFACE (SOUP_TYPE_MESSAGE_FILTER, + filter_iface_init)) enum { AUTHENTICATE, @@ -83,15 +87,15 @@ enum { static guint signals[LAST_SIGNAL] = { 0 }; enum { - PROP_0, + PROP_0, - PROP_PROXY_URI, - PROP_MAX_CONNS, - PROP_MAX_CONNS_PER_HOST, - PROP_USE_NTLM, - PROP_SSL_CA_FILE, + PROP_PROXY_URI, + PROP_MAX_CONNS, + PROP_MAX_CONNS_PER_HOST, + PROP_USE_NTLM, + PROP_SSL_CA_FILE, - LAST_PROP + LAST_PROP }; static void set_property (GObject *object, guint prop_id, @@ -100,74 +104,74 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void -init (GObject *object) +soup_session_init (SoupSession *session) { - SoupSession *session = SOUP_SESSION (object); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); - session->priv = g_new0 (SoupSessionPrivate, 1); - session->priv->host_lock = g_mutex_new (); session->queue = soup_message_queue_new (); - session->priv->hosts = g_hash_table_new (host_uri_hash, - host_uri_equal); - session->priv->conns = g_hash_table_new (NULL, NULL); - session->priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT; - session->priv->max_conns_per_host = SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT; + priv->host_lock = g_mutex_new (); + priv->hosts = g_hash_table_new (host_uri_hash, host_uri_equal); + priv->conns = g_hash_table_new (NULL, NULL); + + priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT; + priv->max_conns_per_host = SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT; } static gboolean -foreach_free_host (gpointer key, gpointer host, gpointer session) +foreach_free_host (gpointer key, gpointer host, gpointer data) { - free_host (host, session); + free_host (host); return TRUE; } static void -cleanup_hosts (SoupSession *session) +cleanup_hosts (SoupSessionPrivate *priv) { - g_hash_table_foreach_remove (session->priv->hosts, - foreach_free_host, session); + g_hash_table_foreach_remove (priv->hosts, foreach_free_host, NULL); } static void dispose (GObject *object) { SoupSession *session = SOUP_SESSION (object); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); GSList *f; soup_session_abort (session); - cleanup_hosts (session); + cleanup_hosts (priv); - if (session->priv->filters) { - for (f = session->priv->filters; f; f = f->next) + if (priv->filters) { + for (f = priv->filters; f; f = f->next) g_object_unref (f->data); - g_slist_free (session->priv->filters); - session->priv->filters = NULL; + g_slist_free (priv->filters); + priv->filters = NULL; } - G_OBJECT_CLASS (parent_class)->dispose (object); + G_OBJECT_CLASS (soup_session_parent_class)->dispose (object); } static void finalize (GObject *object) { SoupSession *session = SOUP_SESSION (object); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); - g_mutex_free (session->priv->host_lock); soup_message_queue_destroy (session->queue); - g_hash_table_destroy (session->priv->hosts); - g_hash_table_destroy (session->priv->conns); - g_free (session->priv); - G_OBJECT_CLASS (parent_class)->finalize (object); + g_mutex_free (priv->host_lock); + g_hash_table_destroy (priv->hosts); + g_hash_table_destroy (priv->conns); + + G_OBJECT_CLASS (soup_session_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_session_class_init (SoupSessionClass *session_class) { - SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class); + GObjectClass *object_class = G_OBJECT_CLASS (session_class); - parent_class = g_type_class_ref (PARENT_TYPE); + g_type_class_add_private (session_class, sizeof (SoupSessionPrivate)); /* virtual method definition */ session_class->queue_message = queue_message; @@ -243,10 +247,10 @@ class_init (GObjectClass *object_class) g_object_class_install_property ( object_class, PROP_SSL_CA_FILE, g_param_spec_string (SOUP_SESSION_SSL_CA_FILE, - "SSL CA file", - "File containing SSL CA certificates", - NULL, - G_PARAM_READWRITE)); + "SSL CA file", + "File containing SSL CA certificates", + NULL, + G_PARAM_READWRITE)); } static void @@ -256,7 +260,6 @@ filter_iface_init (SoupMessageFilterClass *filter_class) filter_class->setup_message = setup_message; } -SOUP_MAKE_TYPE_WITH_IFACE (soup_session, SoupSession, class_init, init, PARENT_TYPE, filter_iface_init, SOUP_TYPE_MESSAGE_FILTER) static gboolean safe_uri_equal (const SoupUri *a, const SoupUri *b) @@ -287,6 +290,7 @@ set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { SoupSession *session = SOUP_SESSION (object); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); gpointer pval; gboolean need_abort = FALSE; gboolean ca_file_changed = FALSE; @@ -296,45 +300,45 @@ set_property (GObject *object, guint prop_id, case PROP_PROXY_URI: pval = g_value_get_pointer (value); - if (!safe_uri_equal (session->priv->proxy_uri, pval)) + if (!safe_uri_equal (priv->proxy_uri, pval)) need_abort = TRUE; - if (session->priv->proxy_uri) - soup_uri_free (session->priv->proxy_uri); + if (priv->proxy_uri) + soup_uri_free (priv->proxy_uri); - session->priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL; + priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL; if (need_abort) { soup_session_abort (session); - cleanup_hosts (session); + cleanup_hosts (priv); } break; case PROP_MAX_CONNS: - session->priv->max_conns = g_value_get_int (value); + priv->max_conns = g_value_get_int (value); break; case PROP_MAX_CONNS_PER_HOST: - session->priv->max_conns_per_host = g_value_get_int (value); + priv->max_conns_per_host = g_value_get_int (value); break; case PROP_USE_NTLM: - session->priv->use_ntlm = g_value_get_boolean (value); + priv->use_ntlm = g_value_get_boolean (value); break; case PROP_SSL_CA_FILE: new_ca_file = g_value_get_string (value); - if (!safe_str_equal (session->priv->ssl_ca_file, new_ca_file)) + if (!safe_str_equal (priv->ssl_ca_file, new_ca_file)) ca_file_changed = TRUE; - g_free (session->priv->ssl_ca_file); - session->priv->ssl_ca_file = g_strdup (new_ca_file); + g_free (priv->ssl_ca_file); + priv->ssl_ca_file = g_strdup (new_ca_file); if (ca_file_changed) { - if (session->priv->ssl_creds) { - soup_ssl_free_client_credentials (session->priv->ssl_creds); - session->priv->ssl_creds = NULL; + if (priv->ssl_creds) { + soup_ssl_free_client_credentials (priv->ssl_creds); + priv->ssl_creds = NULL; } - cleanup_hosts (session); + cleanup_hosts (priv); } break; @@ -348,24 +352,25 @@ get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SoupSession *session = SOUP_SESSION (object); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); switch (prop_id) { case PROP_PROXY_URI: - g_value_set_pointer (value, session->priv->proxy_uri ? - soup_uri_copy (session->priv->proxy_uri) : + g_value_set_pointer (value, priv->proxy_uri ? + soup_uri_copy (priv->proxy_uri) : NULL); break; case PROP_MAX_CONNS: - g_value_set_int (value, session->priv->max_conns); + g_value_set_int (value, priv->max_conns); break; case PROP_MAX_CONNS_PER_HOST: - g_value_set_int (value, session->priv->max_conns_per_host); + g_value_set_int (value, priv->max_conns_per_host); break; case PROP_USE_NTLM: - g_value_set_boolean (value, session->priv->use_ntlm); + g_value_set_boolean (value, priv->use_ntlm); break; case PROP_SSL_CA_FILE: - g_value_set_string (value, session->priv->ssl_ca_file); + g_value_set_string (value, priv->ssl_ca_file); break; default: break; @@ -384,12 +389,14 @@ get_property (GObject *object, guint prop_id, void soup_session_add_filter (SoupSession *session, SoupMessageFilter *filter) { + SoupSessionPrivate *priv; + g_return_if_fail (SOUP_IS_SESSION (session)); g_return_if_fail (SOUP_IS_MESSAGE_FILTER (filter)); + priv = SOUP_SESSION_GET_PRIVATE (session); g_object_ref (filter); - session->priv->filters = g_slist_prepend (session->priv->filters, - filter); + priv->filters = g_slist_prepend (priv->filters, filter); } /** @@ -402,11 +409,13 @@ soup_session_add_filter (SoupSession *session, SoupMessageFilter *filter) void soup_session_remove_filter (SoupSession *session, SoupMessageFilter *filter) { + SoupSessionPrivate *priv; + g_return_if_fail (SOUP_IS_SESSION (session)); g_return_if_fail (SOUP_IS_MESSAGE_FILTER (filter)); + priv = SOUP_SESSION_GET_PRIVATE (session); - session->priv->filters = g_slist_remove (session->priv->filters, - filter); + priv->filters = g_slist_remove (priv->filters, filter); g_object_unref (filter); } @@ -437,15 +446,16 @@ host_uri_equal (gconstpointer v1, gconstpointer v2) static SoupSessionHost * soup_session_host_new (SoupSession *session, const SoupUri *source_uri) { + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupSessionHost *host; host = g_new0 (SoupSessionHost, 1); host->root_uri = soup_uri_copy_root (source_uri); if (host->root_uri->protocol == SOUP_PROTOCOL_HTTPS && - !session->priv->ssl_creds) { - session->priv->ssl_creds = - soup_ssl_get_client_credentials (session->priv->ssl_ca_file); + !priv->ssl_creds) { + priv->ssl_creds = + soup_ssl_get_client_credentials (priv->ssl_ca_file); } return host; @@ -458,15 +468,16 @@ soup_session_host_new (SoupSession *session, const SoupUri *source_uri) static SoupSessionHost * get_host_for_message (SoupSession *session, SoupMessage *msg) { + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupSessionHost *host; const SoupUri *source = soup_message_get_uri (msg); - host = g_hash_table_lookup (session->priv->hosts, source); + host = g_hash_table_lookup (priv->hosts, source); if (host) return host; host = soup_session_host_new (session, source); - g_hash_table_insert (session->priv->hosts, host->root_uri, host); + g_hash_table_insert (priv->hosts, host->root_uri, host); return host; } @@ -477,12 +488,14 @@ get_host_for_message (SoupSession *session, SoupMessage *msg) static SoupSessionHost * get_proxy_host (SoupSession *session) { - if (session->priv->proxy_host || !session->priv->proxy_uri) - return session->priv->proxy_host; + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); + + if (priv->proxy_host || !priv->proxy_uri) + return priv->proxy_host; - session->priv->proxy_host = - soup_session_host_new (session, session->priv->proxy_uri); - return session->priv->proxy_host; + priv->proxy_host = + soup_session_host_new (session, priv->proxy_uri); + return priv->proxy_host; } static void @@ -500,7 +513,7 @@ free_auth (gpointer scheme_realm, gpointer auth, gpointer data) } static void -free_host (SoupSessionHost *host, SoupSession *session) +free_host (SoupSessionHost *host) { while (host->connections) { SoupConnection *conn = host->connections->data; @@ -589,11 +602,12 @@ authenticate_auth (SoupSession *session, SoupAuth *auth, SoupMessage *msg, gboolean prior_auth_failed, gboolean proxy) { + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); const SoupUri *uri; char *username = NULL, *password = NULL; if (proxy) - uri = session->priv->proxy_uri; + uri = priv->proxy_uri; else uri = soup_message_get_uri (msg); @@ -821,9 +835,10 @@ static void setup_message (SoupMessageFilter *filter, SoupMessage *msg) { SoupSession *session = SOUP_SESSION (filter); + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); GSList *f; - for (f = session->priv->filters; f; f = f->next) { + for (f = priv->filters; f; f = f->next) { filter = f->data; soup_message_filter_setup_message (filter, msg); } @@ -834,7 +849,7 @@ setup_message (SoupMessageFilter *filter, SoupMessage *msg) SOUP_HANDLER_POST_BODY, authorize_handler, session); - if (session->priv->proxy_uri) { + if (priv->proxy_uri) { add_auth (session, msg, TRUE); soup_message_add_status_code_handler ( msg, SOUP_STATUS_PROXY_UNAUTHORIZED, @@ -873,22 +888,23 @@ find_oldest_connection (gpointer key, gpointer host, gpointer data) gboolean soup_session_try_prune_connection (SoupSession *session) { + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupConnection *oldest = NULL; - g_mutex_lock (session->priv->host_lock); - g_hash_table_foreach (session->priv->conns, find_oldest_connection, + g_mutex_lock (priv->host_lock); + g_hash_table_foreach (priv->conns, find_oldest_connection, &oldest); if (oldest) { /* Ref the connection before unlocking the mutex in * case someone else tries to prune it too. */ g_object_ref (oldest); - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); soup_connection_disconnect (oldest); g_object_unref (oldest); return TRUE; } else { - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); return FALSE; } } @@ -897,21 +913,22 @@ static void connection_disconnected (SoupConnection *conn, gpointer user_data) { SoupSession *session = user_data; + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupSessionHost *host; - g_mutex_lock (session->priv->host_lock); + g_mutex_lock (priv->host_lock); - host = g_hash_table_lookup (session->priv->conns, conn); + host = g_hash_table_lookup (priv->conns, conn); if (host) { - g_hash_table_remove (session->priv->conns, conn); + g_hash_table_remove (priv->conns, conn); host->connections = g_slist_remove (host->connections, conn); host->num_conns--; } g_signal_handlers_disconnect_by_func (conn, connection_disconnected, session); - session->priv->num_conns--; + priv->num_conns--; - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); g_object_unref (conn); } @@ -919,27 +936,28 @@ static void connect_result (SoupConnection *conn, guint status, gpointer user_data) { SoupSession *session = user_data; + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupSessionHost *host; SoupMessageQueueIter iter; SoupMessage *msg; - g_mutex_lock (session->priv->host_lock); + g_mutex_lock (priv->host_lock); - host = g_hash_table_lookup (session->priv->conns, conn); + host = g_hash_table_lookup (priv->conns, conn); if (!host) { - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); return; } if (status == SOUP_STATUS_OK) { soup_connection_reserve (conn); host->connections = g_slist_prepend (host->connections, conn); - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); return; } /* The connection failed. */ - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); connection_disconnected (conn, session); if (host->connections) { @@ -1014,17 +1032,18 @@ SoupConnection * soup_session_get_connection (SoupSession *session, SoupMessage *msg, gboolean *try_pruning, gboolean *is_new) { + SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupConnection *conn; SoupSessionHost *host; GSList *conns; - g_mutex_lock (session->priv->host_lock); + g_mutex_lock (priv->host_lock); host = get_host_for_message (session, msg); for (conns = host->connections; conns; conns = conns->next) { if (!soup_connection_is_in_use (conns->data)) { soup_connection_reserve (conns->data); - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); *is_new = FALSE; return conns->data; } @@ -1034,33 +1053,33 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg, /* We already started a connection for this * message, so don't start another one. */ - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); return NULL; } - if (host->num_conns >= session->priv->max_conns_per_host) { - g_mutex_unlock (session->priv->host_lock); + if (host->num_conns >= priv->max_conns_per_host) { + g_mutex_unlock (priv->host_lock); return NULL; } - if (session->priv->num_conns >= session->priv->max_conns) { + if (priv->num_conns >= priv->max_conns) { *try_pruning = TRUE; - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); return NULL; } - /* Make sure session->priv->proxy_host gets set now while + /* Make sure priv->proxy_host gets set now while * we have the host_lock. */ - if (session->priv->proxy_uri) + if (priv->proxy_uri) get_proxy_host (session); conn = g_object_new ( - (session->priv->use_ntlm ? + (priv->use_ntlm ? SOUP_TYPE_CONNECTION_NTLM : SOUP_TYPE_CONNECTION), SOUP_CONNECTION_ORIGIN_URI, host->root_uri, - SOUP_CONNECTION_PROXY_URI, session->priv->proxy_uri, - SOUP_CONNECTION_SSL_CREDENTIALS, session->priv->ssl_creds, + SOUP_CONNECTION_PROXY_URI, priv->proxy_uri, + SOUP_CONNECTION_SSL_CREDENTIALS, priv->ssl_creds, SOUP_CONNECTION_MESSAGE_FILTER, session, NULL); g_signal_connect (conn, "connect_result", @@ -1076,13 +1095,13 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg, G_CALLBACK (connection_reauthenticate), session); - g_hash_table_insert (session->priv->conns, conn, host); + g_hash_table_insert (priv->conns, conn, host); /* We increment the connection counts so it counts against the * totals, but we don't add it to the host's connection list * yet, since it's not ready for use. */ - session->priv->num_conns++; + priv->num_conns++; host->num_conns++; /* Mark the request as connecting, so we don't try to open @@ -1090,7 +1109,7 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg, */ msg->status = SOUP_MESSAGE_STATUS_CONNECTING; - g_mutex_unlock (session->priv->host_lock); + g_mutex_unlock (priv->host_lock); *is_new = TRUE; return conn; } diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h index 8e5be50..cdafd96 100644 --- a/libsoup/soup-session.h +++ b/libsoup/soup-session.h @@ -17,13 +17,9 @@ #define SOUP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION)) #define SOUP_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION, SoupSessionClass)) -typedef struct SoupSessionPrivate SoupSessionPrivate; - struct SoupSession { GObject parent; - SoupSessionPrivate *priv; - /* protected */ SoupMessageQueue *queue; }; diff --git a/libsoup/soup-soap-message.c b/libsoup/soup-soap-message.c index 3d552ac..89c5907 100644 --- a/libsoup/soup-soap-message.c +++ b/libsoup/soup-soap-message.c @@ -8,9 +8,9 @@ #include "soup-soap-message.h" #include "soup-uri.h" -#define PARENT_TYPE SOUP_TYPE_MESSAGE +G_DEFINE_TYPE (SoupSoapMessage, soup_soap_message, SOUP_TYPE_MESSAGE) -struct _SoupSoapMessagePrivate { +typedef struct { /* Serialization fields */ xmlDocPtr doc; xmlNodePtr last_node; @@ -20,77 +20,58 @@ struct _SoupSoapMessagePrivate { gchar *env_uri; gboolean body_started; gchar *action; -}; - -static GObjectClass *parent_class = NULL; +} SoupSoapMessagePrivate; +#define SOUP_SOAP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessagePrivate)) static void finalize (GObject *object) { - SoupSoapMessage *msg = SOUP_SOAP_MESSAGE (object); - SoupSoapMessagePrivate *priv; - - /* free memory */ - - priv = msg->priv; + SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (object); if (priv->doc) xmlFreeDoc (priv->doc); - priv->doc = NULL; - if (priv->action) g_free (priv->action); - priv->action = NULL; - - if (priv->env_uri) + if (priv->env_uri) g_free (priv->env_uri); - priv->env_uri = NULL; - if (priv->env_prefix) g_free (priv->env_prefix); - priv->env_prefix = NULL; - - g_free (msg->priv); - msg->priv = NULL; - parent_class->finalize (object); + G_OBJECT_CLASS (soup_soap_message_parent_class)->finalize (object); } static void -class_init (SoupSoapMessageClass *klass) +soup_soap_message_class_init (SoupSoapMessageClass *soup_soap_message_class) { - GObjectClass *object_class; + GObjectClass *object_class = G_OBJECT_CLASS (soup_soap_message_class); - parent_class = g_type_class_peek_parent (klass); - - object_class = G_OBJECT_CLASS (klass); object_class->finalize = finalize; } static void -init (SoupSoapMessage *msg, SoupSoapMessageClass *klass) +soup_soap_message_init (SoupSoapMessage *msg) { - msg->priv = g_new0 (SoupSoapMessagePrivate, 1); + SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); /* initialize XML structures */ - msg->priv->doc = xmlNewDoc ("1.0"); - msg->priv->doc->standalone = FALSE; - msg->priv->doc->encoding = g_strdup ("UTF-8"); + priv->doc = xmlNewDoc ("1.0"); + priv->doc->standalone = FALSE; + priv->doc->encoding = g_strdup ("UTF-8"); } -SOUP_MAKE_TYPE (soup_soap_message, SoupSoapMessage, class_init, init, PARENT_TYPE) static xmlNsPtr fetch_ns (SoupSoapMessage *msg, const char *prefix, const char *ns_uri) { + SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); xmlNsPtr ns = NULL; if (prefix && ns_uri) - ns = xmlNewNs (msg->priv->last_node, ns_uri, prefix); + ns = xmlNewNs (priv->last_node, ns_uri, prefix); else if (prefix && !ns_uri) { - ns = xmlSearchNs (msg->priv->doc, msg->priv->last_node, prefix); + ns = xmlSearchNs (priv->doc, priv->last_node, prefix); if (!ns) - ns = xmlNewNs (msg->priv->last_node, "", prefix); + ns = xmlNewNs (priv->last_node, "", prefix); } return ns; @@ -141,21 +122,23 @@ soup_soap_message_new_from_uri (const char *method, const SoupUri *uri, const char *env_prefix, const char *env_uri) { SoupSoapMessage *msg; + SoupSoapMessagePrivate *priv; msg = g_object_new (SOUP_TYPE_SOAP_MESSAGE, NULL); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); SOUP_MESSAGE (msg)->method = method ? method : SOUP_METHOD_GET; soup_message_set_uri (SOUP_MESSAGE (msg), (const SoupUri *) uri); - msg->priv->doc->standalone = standalone; + priv->doc->standalone = standalone; if (xml_encoding) { - g_free ((char *) msg->priv->doc->encoding); - msg->priv->doc->encoding = g_strdup (xml_encoding); + g_free ((char *) priv->doc->encoding); + priv->doc->encoding = g_strdup (xml_encoding); } if (env_prefix || env_uri) { - msg->priv->env_prefix = g_strdup (env_prefix); - msg->priv->env_uri = g_strdup (env_uri); + priv->env_prefix = g_strdup (env_prefix); + priv->env_uri = g_strdup (env_uri); } return msg; @@ -170,38 +153,41 @@ soup_soap_message_new_from_uri (const char *method, const SoupUri *uri, void soup_soap_message_start_envelope (SoupSoapMessage *msg) { - g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); - - msg->priv->last_node = msg->priv->doc->xmlRootNode = - xmlNewDocNode (msg->priv->doc, NULL, "Envelope", NULL); + SoupSoapMessagePrivate *priv; - msg->priv->soap_ns = xmlNewNs (msg->priv->doc->xmlRootNode, - msg->priv->env_uri ? msg->priv->env_uri : - "http://schemas.xmlsoap.org/soap/envelope/", - msg->priv->env_prefix ? msg->priv->env_prefix : "SOAP-ENV"); - if (msg->priv->env_uri) { - g_free (msg->priv->env_uri); - msg->priv->env_uri = NULL; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); + + priv->last_node = priv->doc->xmlRootNode = + xmlNewDocNode (priv->doc, NULL, "Envelope", NULL); + + priv->soap_ns = xmlNewNs (priv->doc->xmlRootNode, + priv->env_uri ? priv->env_uri : + "http://schemas.xmlsoap.org/soap/envelope/", + priv->env_prefix ? priv->env_prefix : "SOAP-ENV"); + if (priv->env_uri) { + g_free (priv->env_uri); + priv->env_uri = NULL; } - if (msg->priv->env_prefix) { - g_free (msg->priv->env_prefix); - msg->priv->env_prefix = NULL; + if (priv->env_prefix) { + g_free (priv->env_prefix); + priv->env_prefix = NULL; } - xmlSetNs (msg->priv->doc->xmlRootNode, msg->priv->soap_ns); + xmlSetNs (priv->doc->xmlRootNode, priv->soap_ns); - xmlNewNs (msg->priv->doc->xmlRootNode, + xmlNewNs (priv->doc->xmlRootNode, "http://schemas.xmlsoap.org/soap/encoding/", "SOAP-ENC"); - xmlNewNs (msg->priv->doc->xmlRootNode, + xmlNewNs (priv->doc->xmlRootNode, "http://www.w3.org/1999/XMLSchema", "xsd"); - xmlNewNs (msg->priv->doc->xmlRootNode, + xmlNewNs (priv->doc->xmlRootNode, "http://schemas.xmlsoap.org/soap/envelope/", "SOAP-ENV"); - msg->priv->xsi_ns = xmlNewNs (msg->priv->doc->xmlRootNode, - "http://www.w3.org/1999/XMLSchema-instance", - "xsi"); + priv->xsi_ns = xmlNewNs (priv->doc->xmlRootNode, + "http://www.w3.org/1999/XMLSchema-instance", + "xsi"); } /** @@ -225,16 +211,19 @@ soup_soap_message_end_envelope (SoupSoapMessage *msg) void soup_soap_message_start_body (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - if (msg->priv->body_started) + if (priv->body_started) return; - msg->priv->last_node = xmlNewChild (msg->priv->last_node, - msg->priv->soap_ns, - "Body", NULL); + priv->last_node = xmlNewChild (priv->last_node, + priv->soap_ns, + "Body", NULL); - msg->priv->body_started = TRUE; + priv->body_started = TRUE; } /** @@ -275,15 +264,18 @@ soup_soap_message_start_element (SoupSoapMessage *msg, const char *prefix, const char *ns_uri) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - msg->priv->last_node = xmlNewChild (msg->priv->last_node, NULL, name, NULL); + priv->last_node = xmlNewChild (priv->last_node, NULL, name, NULL); - xmlSetNs (msg->priv->last_node, fetch_ns (msg, prefix, ns_uri)); + xmlSetNs (priv->last_node, fetch_ns (msg, prefix, ns_uri)); - if (msg->priv->body_started && !msg->priv->action) - msg->priv->action = g_strconcat (ns_uri ? ns_uri : "", - "#", name, NULL); + if (priv->body_started && !priv->action) + priv->action = g_strconcat (ns_uri ? ns_uri : "", + "#", name, NULL); } /** @@ -295,9 +287,12 @@ soup_soap_message_start_element (SoupSoapMessage *msg, void soup_soap_message_end_element (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - msg->priv->last_node = msg->priv->last_node->parent; + priv->last_node = priv->last_node->parent; } /** @@ -320,16 +315,19 @@ soup_soap_message_start_fault (SoupSoapMessage *msg, const char *faultstring, const char *faultfactor) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - msg->priv->last_node = xmlNewChild (msg->priv->last_node, - msg->priv->soap_ns, - "Fault", NULL); - xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, "faultcode", faultcode); - xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, "faultstring", faultstring); + priv->last_node = xmlNewChild (priv->last_node, + priv->soap_ns, + "Fault", NULL); + xmlNewChild (priv->last_node, priv->soap_ns, "faultcode", faultcode); + xmlNewChild (priv->last_node, priv->soap_ns, "faultstring", faultstring); - msg->priv->last_node = xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, - "faultfactor", faultfactor); + priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns, + "faultfactor", faultfactor); if (!faultfactor) soup_soap_message_set_null (msg); @@ -358,12 +356,15 @@ soup_soap_message_end_fault (SoupSoapMessage *msg) void soup_soap_message_start_fault_detail (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - msg->priv->last_node = xmlNewChild (msg->priv->last_node, - msg->priv->soap_ns, - "detail", - NULL); + priv->last_node = xmlNewChild (priv->last_node, + priv->soap_ns, + "detail", + NULL); } /** @@ -393,10 +394,13 @@ soup_soap_message_end_fault_detail (SoupSoapMessage *msg) void soup_soap_message_start_header (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - msg->priv->last_node = xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, - "Header", NULL); + priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns, + "Header", NULL); } /** @@ -431,13 +435,16 @@ soup_soap_message_start_header_element (SoupSoapMessage *msg, const char *prefix, const char *ns_uri) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); soup_soap_message_start_element (msg, name, prefix, ns_uri); if (actor_uri) - xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "actorUri", actor_uri); + xmlNewNsProp (priv->last_node, priv->soap_ns, "actorUri", actor_uri); if (must_understand) - xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "mustUnderstand", "1"); + xmlNewNsProp (priv->last_node, priv->soap_ns, "mustUnderstand", "1"); } /** @@ -521,9 +528,12 @@ soup_soap_message_write_time (SoupSoapMessage *msg, const time_t *timeval) void soup_soap_message_write_string (SoupSoapMessage *msg, const char *string) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNodeAddContent (msg->priv->last_node, string); + xmlNodeAddContent (priv->last_node, string); } /** @@ -537,9 +547,12 @@ soup_soap_message_write_string (SoupSoapMessage *msg, const char *string) void soup_soap_message_write_buffer (SoupSoapMessage *msg, const char *buffer, int len) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNodeAddContentLen (msg->priv->last_node, buffer, len); + xmlNodeAddContentLen (priv->last_node, buffer, len); } /** @@ -553,9 +566,12 @@ soup_soap_message_write_buffer (SoupSoapMessage *msg, const char *buffer, int le void soup_soap_message_set_element_type (SoupSoapMessage *msg, const char *xsi_type) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNewNsProp (msg->priv->last_node, msg->priv->xsi_ns, "type", xsi_type); + xmlNewNsProp (priv->last_node, priv->xsi_ns, "type", xsi_type); } /** @@ -567,9 +583,12 @@ soup_soap_message_set_element_type (SoupSoapMessage *msg, const char *xsi_type) void soup_soap_message_set_null (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNewNsProp (msg->priv->last_node, msg->priv->xsi_ns, "null", "1"); + xmlNewNsProp (priv->last_node, priv->xsi_ns, "null", "1"); } /** @@ -589,9 +608,12 @@ soup_soap_message_add_attribute (SoupSoapMessage *msg, const char *prefix, const char *ns_uri) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNewNsProp (msg->priv->last_node, + xmlNewNsProp (priv->last_node, fetch_ns (msg, prefix, ns_uri), name, value); } @@ -607,9 +629,12 @@ soup_soap_message_add_attribute (SoupSoapMessage *msg, void soup_soap_message_add_namespace (SoupSoapMessage *msg, const char *prefix, const char *ns_uri) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNewNs (msg->priv->last_node, ns_uri ? ns_uri : "", prefix); + xmlNewNs (priv->last_node, ns_uri ? ns_uri : "", prefix); } /** @@ -624,7 +649,10 @@ soup_soap_message_add_namespace (SoupSoapMessage *msg, const char *prefix, const void soup_soap_message_set_default_namespace (SoupSoapMessage *msg, const char *ns_uri) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); soup_soap_message_add_namespace (msg, NULL, ns_uri); } @@ -640,9 +668,12 @@ soup_soap_message_set_default_namespace (SoupSoapMessage *msg, const char *ns_ur void soup_soap_message_set_encoding_style (SoupSoapMessage *msg, const char *enc_style) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "encodingStyle", enc_style); + xmlNewNsProp (priv->last_node, priv->soap_ns, "encodingStyle", enc_style); } /** @@ -654,23 +685,26 @@ soup_soap_message_set_encoding_style (SoupSoapMessage *msg, const char *enc_styl void soup_soap_message_reset (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlFreeDoc (msg->priv->doc); - msg->priv->doc = xmlNewDoc ("1.0"); - msg->priv->last_node = NULL; + xmlFreeDoc (priv->doc); + priv->doc = xmlNewDoc ("1.0"); + priv->last_node = NULL; - g_free (msg->priv->action); - msg->priv->action = NULL; - msg->priv->body_started = FALSE; + g_free (priv->action); + priv->action = NULL; + priv->body_started = FALSE; - if (msg->priv->env_uri) - g_free (msg->priv->env_uri); - msg->priv->env_uri = NULL; + if (priv->env_uri) + g_free (priv->env_uri); + priv->env_uri = NULL; - if (msg->priv->env_prefix) - g_free (msg->priv->env_prefix); - msg->priv->env_prefix = NULL; + if (priv->env_prefix) + g_free (priv->env_prefix); + priv->env_prefix = NULL; } /** @@ -682,12 +716,14 @@ soup_soap_message_reset (SoupSoapMessage *msg) void soup_soap_message_persist (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; xmlChar *body; int len; g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg)); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - xmlDocDumpMemory (msg->priv->doc, &body, &len); + xmlDocDumpMemory (priv->doc, &body, &len); /* serialize to SoupMessage class */ soup_message_set_request (SOUP_MESSAGE (msg), "text/xml", @@ -708,12 +744,14 @@ soup_soap_message_persist (SoupSoapMessage *msg) const char * soup_soap_message_get_namespace_prefix (SoupSoapMessage *msg, const char *ns_uri) { + SoupSoapMessagePrivate *priv; xmlNsPtr ns = NULL; g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); g_return_val_if_fail (ns_uri != NULL, NULL); - ns = xmlSearchNsByHref (msg->priv->doc, msg->priv->last_node, ns_uri); + ns = xmlSearchNsByHref (priv->doc, priv->last_node, ns_uri); if (ns) { if (ns->prefix) return ns->prefix; @@ -736,9 +774,12 @@ soup_soap_message_get_namespace_prefix (SoupSoapMessage *msg, const char *ns_uri xmlDocPtr soup_soap_message_get_xml_doc (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; + g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); - return msg->priv->doc; + return priv->doc; } /** @@ -753,10 +794,12 @@ soup_soap_message_get_xml_doc (SoupSoapMessage *msg) SoupSoapResponse * soup_soap_message_parse_response (SoupSoapMessage *msg) { + SoupSoapMessagePrivate *priv; char *xmlstr; SoupSoapResponse *soap_response; g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL); + priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg); xmlstr = g_malloc0 (SOUP_MESSAGE (msg)->response.length + 1); strncpy (xmlstr, SOUP_MESSAGE (msg)->response.body, SOUP_MESSAGE (msg)->response.length); diff --git a/libsoup/soup-soap-message.h b/libsoup/soup-soap-message.h index 1fef1e6..055a5d6 100644 --- a/libsoup/soup-soap-message.h +++ b/libsoup/soup-soap-message.h @@ -20,11 +20,9 @@ G_BEGIN_DECLS #define SOUP_IS_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_MESSAGE)) #define SOUP_SOAP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessageClass)) -typedef struct _SoupSoapMessagePrivate SoupSoapMessagePrivate; - typedef struct { SoupMessage parent; - SoupSoapMessagePrivate *priv; + } SoupSoapMessage; typedef struct { diff --git a/libsoup/soup-soap-response.c b/libsoup/soup-soap-response.c index b0746d1..e1ad47b 100644 --- a/libsoup/soup-soap-response.c +++ b/libsoup/soup-soap-response.c @@ -10,9 +10,9 @@ #include "soup-soap-response.h" #include "soup-types.h" -#define PARENT_TYPE G_TYPE_OBJECT +G_DEFINE_TYPE (SoupSoapResponse, soup_soap_response, G_TYPE_OBJECT) -struct _SoupSoapResponsePrivate { +typedef struct { /* the XML document */ xmlDocPtr xmldoc; xmlNodePtr xml_root; @@ -20,56 +20,40 @@ struct _SoupSoapResponsePrivate { xmlNodePtr xml_method; xmlNodePtr soap_fault; GList *parameters; -}; - -static GObjectClass *parent_class = NULL; +} SoupSoapResponsePrivate; +#define SOUP_SOAP_RESPONSE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponsePrivate)) static void finalize (GObject *object) { - SoupSoapResponse *response = SOUP_SOAP_RESPONSE (object); - - /* free memory */ - if (response->priv->xmldoc) { - xmlFreeDoc (response->priv->xmldoc); - response->priv->xmldoc = NULL; - } - - response->priv->xml_root = NULL; - response->priv->xml_body = NULL; - response->priv->xml_method = NULL; - - if (response->priv->parameters != NULL) { - g_list_free (response->priv->parameters); - response->priv->parameters = NULL; - } + SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (object); - g_free (response->priv); - response->priv = NULL; + if (priv->xmldoc) + xmlFreeDoc (priv->xmldoc); + if (priv->parameters != NULL) + g_list_free (priv->parameters); - parent_class->finalize (object); + G_OBJECT_CLASS (soup_soap_response_parent_class)->finalize (object); } static void -class_init (SoupSoapResponseClass *klass) +soup_soap_response_class_init (SoupSoapResponseClass *soup_soap_response_class) { - GObjectClass *object_class; + GObjectClass *object_class = G_OBJECT_CLASS (soup_soap_response_class); - parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (soup_soap_response_class, sizeof (SoupSoapResponsePrivate)); - object_class = G_OBJECT_CLASS (klass); object_class->finalize = finalize; } static void -init (SoupSoapResponse *response, SoupSoapResponseClass *klass) +soup_soap_response_init (SoupSoapResponse *response) { - response->priv = g_new0 (SoupSoapResponsePrivate, 1); + SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); - response->priv->xmldoc = xmlNewDoc ("1.0"); + priv->xmldoc = xmlNewDoc ("1.0"); } -SOUP_MAKE_TYPE (soup_soap_response, SoupSoapResponse, class_init, init, PARENT_TYPE) /** * soup_soap_response_new: @@ -114,17 +98,17 @@ soup_soap_response_new_from_string (const char *xmlstr) } static void -parse_parameters (SoupSoapResponse *response, xmlNodePtr xml_method) +parse_parameters (SoupSoapResponsePrivate *priv, xmlNodePtr xml_method) { xmlNodePtr tmp; for (tmp = xml_method->xmlChildrenNode; tmp != NULL; tmp = tmp->next) { if (!strcmp (tmp->name, "Fault")) { - response->priv->soap_fault = tmp; + priv->soap_fault = tmp; continue; } else { /* regular parameters */ - response->priv->parameters = g_list_append (response->priv->parameters, tmp); + priv->parameters = g_list_append (priv->parameters, tmp); } } } @@ -142,33 +126,35 @@ parse_parameters (SoupSoapResponse *response, xmlNodePtr xml_method) gboolean soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr) { + SoupSoapResponsePrivate *priv; xmlDocPtr old_doc = NULL; xmlNodePtr xml_root, xml_body = NULL, xml_method = NULL; g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), FALSE); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); g_return_val_if_fail (xmlstr != NULL, FALSE); /* clear the previous contents */ - if (response->priv->xmldoc) - old_doc = response->priv->xmldoc; + if (priv->xmldoc) + old_doc = priv->xmldoc; /* parse the string */ - response->priv->xmldoc = xmlParseMemory (xmlstr, strlen (xmlstr)); - if (!response->priv->xmldoc) { - response->priv->xmldoc = old_doc; + priv->xmldoc = xmlParseMemory (xmlstr, strlen (xmlstr)); + if (!priv->xmldoc) { + priv->xmldoc = old_doc; return FALSE; } - xml_root = xmlDocGetRootElement (response->priv->xmldoc); + xml_root = xmlDocGetRootElement (priv->xmldoc); if (!xml_root) { - xmlFreeDoc (response->priv->xmldoc); - response->priv->xmldoc = old_doc; + xmlFreeDoc (priv->xmldoc); + priv->xmldoc = old_doc; return FALSE; } if (strcmp (xml_root->name, "Envelope") != 0) { - xmlFreeDoc (response->priv->xmldoc); - response->priv->xmldoc = old_doc; + xmlFreeDoc (priv->xmldoc); + priv->xmldoc = old_doc; return FALSE; } @@ -177,8 +163,8 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr) if (strcmp (xml_body->name, "Header") == 0) xml_body = xml_root->xmlChildrenNode->next; if (strcmp (xml_body->name, "Body") != 0) { - xmlFreeDoc (response->priv->xmldoc); - response->priv->xmldoc = old_doc; + xmlFreeDoc (priv->xmldoc); + priv->xmldoc = old_doc; return FALSE; } @@ -186,14 +172,14 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr) /* read all parameters */ if (xml_method) - parse_parameters (response, xml_method); + parse_parameters (priv, xml_method); } xmlFreeDoc (old_doc); - response->priv->xml_root = xml_root; - response->priv->xml_body = xml_body; - response->priv->xml_method = xml_method; + priv->xml_root = xml_root; + priv->xml_body = xml_body; + priv->xml_method = xml_method; return TRUE; } @@ -209,10 +195,13 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr) const char * soup_soap_response_get_method_name (SoupSoapResponse *response) { + SoupSoapResponsePrivate *priv; + g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL); - g_return_val_if_fail (response->priv->xml_method != NULL, NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); + g_return_val_if_fail (priv->xml_method != NULL, NULL); - return (const char *) response->priv->xml_method->name; + return (const char *) priv->xml_method->name; } /** @@ -225,11 +214,14 @@ soup_soap_response_get_method_name (SoupSoapResponse *response) void soup_soap_response_set_method_name (SoupSoapResponse *response, const char *method_name) { + SoupSoapResponsePrivate *priv; + g_return_if_fail (SOUP_IS_SOAP_RESPONSE (response)); - g_return_if_fail (response->priv->xml_method != NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); + g_return_if_fail (priv->xml_method != NULL); g_return_if_fail (method_name != NULL); - xmlNodeSetName (response->priv->xml_method, method_name); + xmlNodeSetName (priv->xml_method, method_name); } /** @@ -394,9 +386,12 @@ soup_soap_parameter_get_property (SoupSoapParameter *param, const char *prop_nam const GList * soup_soap_response_get_parameters (SoupSoapResponse *response) { + SoupSoapResponsePrivate *priv; + g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); - return (const GList *) response->priv->parameters; + return (const GList *) priv->parameters; } /** @@ -412,9 +407,12 @@ soup_soap_response_get_parameters (SoupSoapResponse *response) SoupSoapParameter * soup_soap_response_get_first_parameter (SoupSoapResponse *response) { + SoupSoapResponsePrivate *priv; + g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); - return response->priv->parameters ? response->priv->parameters->data : NULL; + return priv->parameters ? priv->parameters->data : NULL; } /** @@ -433,12 +431,14 @@ SoupSoapParameter * soup_soap_response_get_first_parameter_by_name (SoupSoapResponse *response, const char *name) { + SoupSoapResponsePrivate *priv; GList *l; g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); g_return_val_if_fail (name != NULL, NULL); - for (l = response->priv->parameters; l != NULL; l = l->next) { + for (l = priv->parameters; l != NULL; l = l->next) { SoupSoapParameter *param = (SoupSoapParameter *) l->data; if (!strcmp (name, param->name)) @@ -461,12 +461,14 @@ SoupSoapParameter * soup_soap_response_get_next_parameter (SoupSoapResponse *response, SoupSoapParameter *from) { + SoupSoapResponsePrivate *priv; GList *l; g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL); + priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response); g_return_val_if_fail (from != NULL, NULL); - l = g_list_find (response->priv->parameters, (gconstpointer) from); + l = g_list_find (priv->parameters, (gconstpointer) from); if (!l) return NULL; diff --git a/libsoup/soup-soap-response.h b/libsoup/soup-soap-response.h index b2a7742..32427e2 100644 --- a/libsoup/soup-soap-response.h +++ b/libsoup/soup-soap-response.h @@ -18,11 +18,9 @@ G_BEGIN_DECLS #define SOUP_IS_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_RESPONSE)) #define SOUP_SOAP_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponseClass)) -typedef struct _SoupSoapResponsePrivate SoupSoapResponsePrivate; - typedef struct { GObject parent; - SoupSoapResponsePrivate *priv; + } SoupSoapResponse; typedef struct { diff --git a/libsoup/soup-socket.c b/libsoup/soup-socket.c index d1de93e..a977029 100644 --- a/libsoup/soup-socket.c +++ b/libsoup/soup-socket.c @@ -26,8 +26,7 @@ #include #include -#define PARENT_TYPE G_TYPE_OBJECT -static GObjectClass *parent_class; +G_DEFINE_TYPE (SoupSocket, soup_socket, G_TYPE_OBJECT) enum { CONNECT_RESULT, @@ -52,7 +51,7 @@ enum { LAST_PROP }; -struct SoupSocketPrivate { +typedef struct { int sockfd; SoupAddress *local_addr, *remote_addr; GIOChannel *iochannel; @@ -68,7 +67,8 @@ struct SoupSocketPrivate { GByteArray *read_buf; GMutex *iolock, *addrlock; -}; +} SoupSocketPrivate; +#define SOUP_SOCKET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOCKET, SoupSocketPrivate)) #ifdef HAVE_IPV6 #define soup_sockaddr_max sockaddr_in6 @@ -82,67 +82,66 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void -init (GObject *object) +soup_socket_init (SoupSocket *sock) { - SoupSocket *sock = SOUP_SOCKET (object); - - sock->priv = g_new0 (SoupSocketPrivate, 1); - sock->priv->sockfd = -1; - sock->priv->non_blocking = sock->priv->nodelay = TRUE; - sock->priv->reuseaddr = TRUE; - sock->priv->addrlock = g_mutex_new (); - sock->priv->iolock = g_mutex_new (); + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); + + priv->sockfd = -1; + priv->non_blocking = priv->nodelay = TRUE; + priv->reuseaddr = TRUE; + priv->addrlock = g_mutex_new (); + priv->iolock = g_mutex_new (); } static void -disconnect_internal (SoupSocket *sock) +disconnect_internal (SoupSocketPrivate *priv) { - g_io_channel_unref (sock->priv->iochannel); - sock->priv->iochannel = NULL; - sock->priv->sockfd = -1; + g_io_channel_unref (priv->iochannel); + priv->iochannel = NULL; + priv->sockfd = -1; - if (sock->priv->read_tag) { - g_source_remove (sock->priv->read_tag); - sock->priv->read_tag = 0; + if (priv->read_tag) { + g_source_remove (priv->read_tag); + priv->read_tag = 0; } - if (sock->priv->write_tag) { - g_source_remove (sock->priv->write_tag); - sock->priv->write_tag = 0; + if (priv->write_tag) { + g_source_remove (priv->write_tag); + priv->write_tag = 0; } - if (sock->priv->error_tag) { - g_source_remove (sock->priv->error_tag); - sock->priv->error_tag = 0; + if (priv->error_tag) { + g_source_remove (priv->error_tag); + priv->error_tag = 0; } } static void finalize (GObject *object) { - SoupSocket *sock = SOUP_SOCKET (object); - - if (sock->priv->iochannel) - disconnect_internal (sock); + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object); - if (sock->priv->local_addr) - g_object_unref (sock->priv->local_addr); - if (sock->priv->remote_addr) - g_object_unref (sock->priv->remote_addr); + if (priv->iochannel) + disconnect_internal (priv); - if (sock->priv->watch) - g_source_remove (sock->priv->watch); + if (priv->local_addr) + g_object_unref (priv->local_addr); + if (priv->remote_addr) + g_object_unref (priv->remote_addr); - g_mutex_free (sock->priv->addrlock); - g_mutex_free (sock->priv->iolock); + if (priv->watch) + g_source_remove (priv->watch); - g_free (sock->priv); + g_mutex_free (priv->addrlock); + g_mutex_free (priv->iolock); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (soup_socket_parent_class)->finalize (object); } static void -class_init (GObjectClass *object_class) +soup_socket_class_init (SoupSocketClass *socket_class) { - parent_class = g_type_class_ref (PARENT_TYPE); + GObjectClass *object_class = G_OBJECT_CLASS (socket_class); + + g_type_class_add_private (socket_class, sizeof (SoupSocketPrivate)); /* virtual method override */ object_class->finalize = finalize; @@ -230,32 +229,30 @@ class_init (GObjectClass *object_class) G_PARAM_READWRITE)); } -SOUP_MAKE_TYPE (soup_socket, SoupSocket, class_init, init, PARENT_TYPE) - static void -update_fdflags (SoupSocket *sock) +update_fdflags (SoupSocketPrivate *priv) { int flags, opt; - if (sock->priv->sockfd == -1) + if (priv->sockfd == -1) return; - flags = fcntl (sock->priv->sockfd, F_GETFL, 0); + flags = fcntl (priv->sockfd, F_GETFL, 0); if (flags != -1) { - if (sock->priv->non_blocking) + if (priv->non_blocking) flags |= O_NONBLOCK; else flags &= ~O_NONBLOCK; - fcntl (sock->priv->sockfd, F_SETFL, flags); + fcntl (priv->sockfd, F_SETFL, flags); } - opt = (sock->priv->nodelay != 0); - setsockopt (sock->priv->sockfd, IPPROTO_TCP, + opt = (priv->nodelay != 0); + setsockopt (priv->sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof (opt)); - opt = (sock->priv->reuseaddr != 0); - setsockopt (sock->priv->sockfd, SOL_SOCKET, + opt = (priv->reuseaddr != 0); + setsockopt (priv->sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)); } @@ -263,23 +260,23 @@ static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { - SoupSocket *sock = SOUP_SOCKET (object); + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object); switch (prop_id) { case PROP_NON_BLOCKING: - sock->priv->non_blocking = g_value_get_boolean (value); - update_fdflags (sock); + priv->non_blocking = g_value_get_boolean (value); + update_fdflags (priv); break; case PROP_NODELAY: - sock->priv->nodelay = g_value_get_boolean (value); - update_fdflags (sock); + priv->nodelay = g_value_get_boolean (value); + update_fdflags (priv); break; case PROP_REUSEADDR: - sock->priv->reuseaddr = g_value_get_boolean (value); - update_fdflags (sock); + priv->reuseaddr = g_value_get_boolean (value); + update_fdflags (priv); break; case PROP_SSL_CREDENTIALS: - sock->priv->ssl_creds = g_value_get_pointer (value); + priv->ssl_creds = g_value_get_pointer (value); break; default: break; @@ -290,23 +287,23 @@ static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { - SoupSocket *sock = SOUP_SOCKET (object); + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object); switch (prop_id) { case PROP_NON_BLOCKING: - g_value_set_boolean (value, sock->priv->non_blocking); + g_value_set_boolean (value, priv->non_blocking); break; case PROP_NODELAY: - g_value_set_boolean (value, sock->priv->nodelay); + g_value_set_boolean (value, priv->nodelay); break; case PROP_REUSEADDR: - g_value_set_boolean (value, sock->priv->reuseaddr); + g_value_set_boolean (value, priv->reuseaddr); break; case PROP_IS_SERVER: - g_value_set_boolean (value, sock->priv->is_server); + g_value_set_boolean (value, priv->is_server); break; case PROP_SSL_CREDENTIALS: - g_value_set_pointer (value, sock->priv->ssl_creds); + g_value_set_pointer (value, priv->ssl_creds); break; default: break; @@ -338,29 +335,30 @@ soup_socket_new (const char *optname1, ...) } static GIOChannel * -get_iochannel (SoupSocket *sock) +get_iochannel (SoupSocketPrivate *priv) { - g_mutex_lock (sock->priv->iolock); - if (!sock->priv->iochannel) { - sock->priv->iochannel = - g_io_channel_unix_new (sock->priv->sockfd); - g_io_channel_set_close_on_unref (sock->priv->iochannel, TRUE); - g_io_channel_set_encoding (sock->priv->iochannel, NULL, NULL); - g_io_channel_set_buffered (sock->priv->iochannel, FALSE); + g_mutex_lock (priv->iolock); + if (!priv->iochannel) { + priv->iochannel = + g_io_channel_unix_new (priv->sockfd); + g_io_channel_set_close_on_unref (priv->iochannel, TRUE); + g_io_channel_set_encoding (priv->iochannel, NULL, NULL); + g_io_channel_set_buffered (priv->iochannel, FALSE); } - g_mutex_unlock (sock->priv->iolock); - return sock->priv->iochannel; + g_mutex_unlock (priv->iolock); + return priv->iochannel; } static gboolean idle_connect_result (gpointer user_data) { SoupSocket *sock = user_data; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); - sock->priv->watch = 0; + priv->watch = 0; g_signal_emit (sock, signals[CONNECT_RESULT], 0, - sock->priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT); + priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT); return FALSE; } @@ -368,17 +366,18 @@ static gboolean connect_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data) { SoupSocket *sock = data; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); int error = 0; int len = sizeof (error); /* Remove the watch now in case we don't return immediately */ - g_source_remove (sock->priv->watch); - sock->priv->watch = 0; + g_source_remove (priv->watch); + priv->watch = 0; if (condition & ~(G_IO_IN | G_IO_OUT)) goto cant_connect; - if (getsockopt (sock->priv->sockfd, SOL_SOCKET, SO_ERROR, + if (getsockopt (priv->sockfd, SOL_SOCKET, SO_ERROR, &error, &len) != 0) goto cant_connect; if (error) @@ -395,6 +394,7 @@ static void got_address (SoupAddress *addr, guint status, gpointer user_data) { SoupSocket *sock = user_data; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) { g_signal_emit (sock, signals[CONNECT_RESULT], 0, status); @@ -402,7 +402,7 @@ got_address (SoupAddress *addr, guint status, gpointer user_data) return; } - soup_socket_connect (sock, sock->priv->remote_addr); + soup_socket_connect (sock, priv->remote_addr); /* soup_socket_connect re-reffed addr */ g_object_unref (addr); @@ -428,24 +428,26 @@ got_address (SoupAddress *addr, guint status, gpointer user_data) guint soup_socket_connect (SoupSocket *sock, SoupAddress *remote_addr) { + SoupSocketPrivate *priv; struct sockaddr *sa; int len, status; g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED); - g_return_val_if_fail (!sock->priv->is_server, SOUP_STATUS_MALFORMED); - g_return_val_if_fail (sock->priv->sockfd == -1, SOUP_STATUS_MALFORMED); + priv = SOUP_SOCKET_GET_PRIVATE (sock); + g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED); + g_return_val_if_fail (priv->sockfd == -1, SOUP_STATUS_MALFORMED); g_return_val_if_fail (SOUP_IS_ADDRESS (remote_addr), SOUP_STATUS_MALFORMED); - sock->priv->remote_addr = g_object_ref (remote_addr); - if (!sock->priv->non_blocking) { + priv->remote_addr = g_object_ref (remote_addr); + if (!priv->non_blocking) { status = soup_address_resolve_sync (remote_addr); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) return status; } - sa = soup_address_get_sockaddr (sock->priv->remote_addr, &len); + sa = soup_address_get_sockaddr (priv->remote_addr, &len); if (!sa) { - if (!sock->priv->non_blocking) + if (!priv->non_blocking) return SOUP_STATUS_CANT_RESOLVE; g_object_ref (sock); @@ -453,38 +455,38 @@ soup_socket_connect (SoupSocket *sock, SoupAddress *remote_addr) return SOUP_STATUS_CONTINUE; } - sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0); - if (sock->priv->sockfd == -1) { + priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0); + if (priv->sockfd == -1) { goto done; } - update_fdflags (sock); + update_fdflags (priv); - status = connect (sock->priv->sockfd, sa, len); + status = connect (priv->sockfd, sa, len); if (status == -1) { if (errno == EINPROGRESS) { /* Wait for connect to succeed or fail */ - sock->priv->watch = - g_io_add_watch (get_iochannel (sock), + priv->watch = + g_io_add_watch (get_iochannel (priv), G_IO_IN | G_IO_OUT | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, connect_watch, sock); return SOUP_STATUS_CONTINUE; } else { - close (sock->priv->sockfd); - sock->priv->sockfd = -1; + close (priv->sockfd); + priv->sockfd = -1; } } done: - if (sock->priv->non_blocking) { - sock->priv->watch = g_idle_add (idle_connect_result, sock); + if (priv->non_blocking) { + priv->watch = g_idle_add (idle_connect_result, sock); return SOUP_STATUS_CONTINUE; - } else if (sock->priv->sockfd == -1) + } else if (priv->sockfd == -1) return SOUP_STATUS_CANT_CONNECT; else { - get_iochannel (sock); + get_iochannel (priv); return SOUP_STATUS_OK; } } @@ -493,37 +495,39 @@ static gboolean listen_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data) { SoupSocket *sock = data, *new; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock), *new_priv; struct soup_sockaddr_max sa; int sa_len, sockfd; if (condition & (G_IO_HUP | G_IO_ERR)) { - g_source_remove (sock->priv->watch); - sock->priv->watch = 0; + g_source_remove (priv->watch); + priv->watch = 0; return FALSE; } sa_len = sizeof (sa); - sockfd = accept (sock->priv->sockfd, (struct sockaddr *)&sa, &sa_len); + sockfd = accept (priv->sockfd, (struct sockaddr *)&sa, &sa_len); if (sockfd == -1) return TRUE; new = g_object_new (SOUP_TYPE_SOCKET, NULL); - new->priv->sockfd = sockfd; - new->priv->non_blocking = sock->priv->non_blocking; - new->priv->nodelay = sock->priv->nodelay; - new->priv->is_server = TRUE; - new->priv->ssl_creds = sock->priv->ssl_creds; - update_fdflags (new); + new_priv = SOUP_SOCKET_GET_PRIVATE (new); + new_priv->sockfd = sockfd; + new_priv->non_blocking = priv->non_blocking; + new_priv->nodelay = priv->nodelay; + new_priv->is_server = TRUE; + new_priv->ssl_creds = priv->ssl_creds; + update_fdflags (new_priv); - new->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len); + new_priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len); - if (new->priv->ssl_creds) { + if (new_priv->ssl_creds) { if (!soup_socket_start_ssl (new)) { g_object_unref (new); return TRUE; } } else - get_iochannel (new); + get_iochannel (new_priv); g_signal_emit (sock, signals[NEW_CONNECTION], 0, new); g_object_unref (new); @@ -545,16 +549,18 @@ listen_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data) gboolean soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr) { + SoupSocketPrivate *priv; struct sockaddr *sa; int sa_len; g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE); - g_return_val_if_fail (sock->priv->is_server, FALSE); - g_return_val_if_fail (sock->priv->sockfd == -1, FALSE); + priv = SOUP_SOCKET_GET_PRIVATE (sock); + g_return_val_if_fail (priv->is_server, FALSE); + g_return_val_if_fail (priv->sockfd == -1, FALSE); g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), FALSE); /* @local_addr may have its port set to 0. So we intentionally - * don't store it in sock->priv->local_addr, so that if the + * don't store it in priv->local_addr, so that if the * caller calls soup_socket_get_local_address() later, we'll * have to make a new addr by calling getsockname(), which * will have the right port number. @@ -562,28 +568,28 @@ soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr) sa = soup_address_get_sockaddr (local_addr, &sa_len); g_return_val_if_fail (sa != NULL, FALSE); - sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0); - if (sock->priv->sockfd < 0) + priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0); + if (priv->sockfd < 0) goto cant_listen; - update_fdflags (sock); + update_fdflags (priv); /* Bind */ - if (bind (sock->priv->sockfd, sa, sa_len) != 0) + if (bind (priv->sockfd, sa, sa_len) != 0) goto cant_listen; /* Listen */ - if (listen (sock->priv->sockfd, 10) != 0) + if (listen (priv->sockfd, 10) != 0) goto cant_listen; - sock->priv->watch = g_io_add_watch (get_iochannel (sock), - G_IO_IN | G_IO_ERR | G_IO_HUP, - listen_watch, sock); + priv->watch = g_io_add_watch (get_iochannel (priv), + G_IO_IN | G_IO_ERR | G_IO_HUP, + listen_watch, sock); return TRUE; cant_listen: - if (sock->priv->sockfd != -1) { - close (sock->priv->sockfd); - sock->priv->sockfd = -1; + if (priv->sockfd != -1) { + close (priv->sockfd); + priv->sockfd = -1; } return FALSE; @@ -600,7 +606,9 @@ soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr) gboolean soup_socket_start_ssl (SoupSocket *sock) { - return soup_socket_start_proxy_ssl (sock, soup_address_get_name (sock->priv->remote_addr)); + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); + + return soup_socket_start_proxy_ssl (sock, soup_address_get_name (priv->remote_addr)); } /** @@ -616,18 +624,19 @@ soup_socket_start_ssl (SoupSocket *sock) gboolean soup_socket_start_proxy_ssl (SoupSocket *sock, const char *ssl_host) { + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); GIOChannel *ssl_chan; - get_iochannel (sock); + get_iochannel (priv); ssl_chan = soup_ssl_wrap_iochannel ( - sock->priv->iochannel, sock->priv->is_server ? + priv->iochannel, priv->is_server ? SOUP_SSL_TYPE_SERVER : SOUP_SSL_TYPE_CLIENT, - ssl_host, sock->priv->ssl_creds); + ssl_host, priv->ssl_creds); if (!ssl_chan) return FALSE; - sock->priv->iochannel = ssl_chan; + priv->iochannel = ssl_chan; return TRUE; } @@ -683,6 +692,7 @@ soup_socket_client_new_sync (const char *hostname, guint port, gpointer ssl_creds, guint *status_ret) { SoupSocket *sock; + SoupSocketPrivate *priv; guint status; g_return_val_if_fail (hostname != NULL, NULL); @@ -690,7 +700,8 @@ soup_socket_client_new_sync (const char *hostname, guint port, sock = g_object_new (SOUP_TYPE_SOCKET, SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds, NULL); - sock->priv->non_blocking = FALSE; + priv = SOUP_SOCKET_GET_PRIVATE (sock); + priv->non_blocking = FALSE; status = soup_socket_connect (sock, soup_address_new (hostname, port)); if (!SOUP_STATUS_IS_SUCCESSFUL (status)) { @@ -723,13 +734,15 @@ soup_socket_server_new (SoupAddress *local_addr, gpointer ssl_creds, gpointer user_data) { SoupSocket *sock; + SoupSocketPrivate *priv; g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), NULL); sock = g_object_new (SOUP_TYPE_SOCKET, SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds, NULL); - sock->priv->is_server = TRUE; + priv = SOUP_SOCKET_GET_PRIVATE (sock); + priv->is_server = TRUE; if (!soup_socket_listen (sock, local_addr)) { g_object_unref (sock); return NULL; @@ -754,16 +767,18 @@ soup_socket_server_new (SoupAddress *local_addr, gpointer ssl_creds, void soup_socket_disconnect (SoupSocket *sock) { + SoupSocketPrivate *priv; gboolean already_disconnected = FALSE; g_return_if_fail (SOUP_IS_SOCKET (sock)); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - if (g_mutex_trylock (sock->priv->iolock)) { - if (sock->priv->iochannel) - disconnect_internal (sock); + if (g_mutex_trylock (priv->iolock)) { + if (priv->iochannel) + disconnect_internal (priv); else already_disconnected = TRUE; - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); } else { int sockfd; @@ -772,12 +787,12 @@ soup_socket_disconnect (SoupSocket *sock) * the file descriptor out from under it. */ - sockfd = sock->priv->sockfd; - sock->priv->sockfd = -1; + sockfd = priv->sockfd; + priv->sockfd = -1; if (sockfd == -1) already_disconnected = TRUE; else { - g_io_channel_set_close_on_unref (sock->priv->iochannel, + g_io_channel_set_close_on_unref (priv->iochannel, FALSE); close (sockfd); } @@ -806,9 +821,12 @@ soup_socket_disconnect (SoupSocket *sock) gboolean soup_socket_is_connected (SoupSocket *sock) { + SoupSocketPrivate *priv; + g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - return sock->priv->iochannel != NULL; + return priv->iochannel != NULL; } /** @@ -822,20 +840,23 @@ soup_socket_is_connected (SoupSocket *sock) SoupAddress * soup_socket_get_local_address (SoupSocket *sock) { + SoupSocketPrivate *priv; + g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - g_mutex_lock (sock->priv->addrlock); - if (!sock->priv->local_addr) { + g_mutex_lock (priv->addrlock); + if (!priv->local_addr) { struct soup_sockaddr_max bound_sa; int sa_len; sa_len = sizeof (bound_sa); - getsockname (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len); - sock->priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len); + getsockname (priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len); + priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len); } - g_mutex_unlock (sock->priv->addrlock); + g_mutex_unlock (priv->addrlock); - return sock->priv->local_addr; + return priv->local_addr; } /** @@ -849,20 +870,23 @@ soup_socket_get_local_address (SoupSocket *sock) SoupAddress * soup_socket_get_remote_address (SoupSocket *sock) { + SoupSocketPrivate *priv; + g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - g_mutex_lock (sock->priv->addrlock); - if (!sock->priv->remote_addr) { + g_mutex_lock (priv->addrlock); + if (!priv->remote_addr) { struct soup_sockaddr_max bound_sa; int sa_len; sa_len = sizeof (bound_sa); - getpeername (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len); - sock->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len); + getpeername (priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len); + priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len); } - g_mutex_unlock (sock->priv->addrlock); + g_mutex_unlock (priv->addrlock); - return sock->priv->remote_addr; + return priv->remote_addr; } @@ -872,8 +896,9 @@ static gboolean socket_read_watch (GIOChannel *chan, GIOCondition cond, gpointer user_data) { SoupSocket *sock = user_data; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); - sock->priv->read_tag = 0; + priv->read_tag = 0; g_signal_emit (sock, signals[READABLE], 0); return FALSE; @@ -882,14 +907,15 @@ socket_read_watch (GIOChannel *chan, GIOCondition cond, gpointer user_data) static SoupSocketIOStatus read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) { + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); GIOStatus status; GIOCondition cond = G_IO_IN; GError *err = NULL; - if (!sock->priv->iochannel) + if (!priv->iochannel) return SOUP_SOCKET_EOF; - status = g_io_channel_read_chars (sock->priv->iochannel, + status = g_io_channel_read_chars (priv->iochannel, buffer, len, nread, &err); if (err) { if (err->domain == SOUP_SSL_ERROR && @@ -910,9 +936,9 @@ read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) if (*nread > 0) return SOUP_SOCKET_OK; - if (!sock->priv->read_tag) { - sock->priv->read_tag = - g_io_add_watch (sock->priv->iochannel, cond, + if (!priv->read_tag) { + priv->read_tag = + g_io_add_watch (priv->iochannel, cond, socket_read_watch, sock); } return SOUP_SOCKET_WOULD_BLOCK; @@ -928,14 +954,15 @@ read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) static SoupSocketIOStatus read_from_buf (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) { - GByteArray *read_buf = sock->priv->read_buf; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); + GByteArray *read_buf = priv->read_buf; *nread = MIN (read_buf->len, len); memcpy (buffer, read_buf->data, *nread); if (*nread == read_buf->len) { g_byte_array_free (read_buf, TRUE); - sock->priv->read_buf = NULL; + priv->read_buf = NULL; } else { memmove (read_buf->data, read_buf->data + *nread, read_buf->len - *nread); @@ -971,16 +998,18 @@ read_from_buf (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) SoupSocketIOStatus soup_socket_read (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread) { + SoupSocketPrivate *priv; SoupSocketIOStatus status; g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - g_mutex_lock (sock->priv->iolock); - if (sock->priv->read_buf) + g_mutex_lock (priv->iolock); + if (priv->read_buf) status = read_from_buf (sock, buffer, len, nread); else status = read_from_network (sock, buffer, len, nread); - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return status; } @@ -1008,21 +1037,23 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len, gconstpointer boundary, gsize boundary_len, gsize *nread, gboolean *got_boundary) { + SoupSocketPrivate *priv; SoupSocketIOStatus status; GByteArray *read_buf; guint match_len, prev_len; guint8 *p, *end; g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR); + priv = SOUP_SOCKET_GET_PRIVATE (sock); g_return_val_if_fail (len >= boundary_len, SOUP_SOCKET_ERROR); - g_mutex_lock (sock->priv->iolock); + g_mutex_lock (priv->iolock); *got_boundary = FALSE; - if (!sock->priv->read_buf) - sock->priv->read_buf = g_byte_array_new (); - read_buf = sock->priv->read_buf; + if (!priv->read_buf) + priv->read_buf = g_byte_array_new (); + read_buf = priv->read_buf; if (read_buf->len < boundary_len) { prev_len = read_buf->len; @@ -1033,7 +1064,7 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len, read_buf->len = prev_len + *nread; if (status != SOUP_SOCKET_OK) { - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return status; } } @@ -1055,7 +1086,7 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len, match_len = p - read_buf->data; status = read_from_buf (sock, buffer, MIN (len, match_len), nread); - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return status; } @@ -1063,8 +1094,9 @@ static gboolean socket_write_watch (GIOChannel *chan, GIOCondition condition, gpointer user_data) { SoupSocket *sock = user_data; + SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock); - sock->priv->write_tag = 0; + priv->write_tag = 0; g_signal_emit (sock, signals[WRITABLE], 0); return FALSE; @@ -1095,26 +1127,28 @@ SoupSocketIOStatus soup_socket_write (SoupSocket *sock, gconstpointer buffer, gsize len, gsize *nwrote) { + SoupSocketPrivate *priv; GIOStatus status; gpointer pipe_handler; GIOCondition cond = G_IO_OUT; GError *err = NULL; g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR); + priv = SOUP_SOCKET_GET_PRIVATE (sock); - g_mutex_lock (sock->priv->iolock); + g_mutex_lock (priv->iolock); - if (!sock->priv->iochannel) { - g_mutex_unlock (sock->priv->iolock); + if (!priv->iochannel) { + g_mutex_unlock (priv->iolock); return SOUP_SOCKET_EOF; } - if (sock->priv->write_tag) { - g_mutex_unlock (sock->priv->iolock); + if (priv->write_tag) { + g_mutex_unlock (priv->iolock); return SOUP_SOCKET_WOULD_BLOCK; } pipe_handler = signal (SIGPIPE, SIG_IGN); - status = g_io_channel_write_chars (sock->priv->iochannel, + status = g_io_channel_write_chars (priv->iochannel, buffer, len, nwrote, &err); signal (SIGPIPE, pipe_handler); if (err) { @@ -1131,18 +1165,18 @@ soup_socket_write (SoupSocket *sock, gconstpointer buffer, } if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN) { - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return SOUP_SOCKET_ERROR; } if (*nwrote) { - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return SOUP_SOCKET_OK; } - sock->priv->write_tag = - g_io_add_watch (sock->priv->iochannel, cond, + priv->write_tag = + g_io_add_watch (priv->iochannel, cond, socket_write_watch, sock); - g_mutex_unlock (sock->priv->iolock); + g_mutex_unlock (priv->iolock); return SOUP_SOCKET_WOULD_BLOCK; } diff --git a/libsoup/soup-socket.h b/libsoup/soup-socket.h index 49e88a9..bb43caa 100644 --- a/libsoup/soup-socket.h +++ b/libsoup/soup-socket.h @@ -15,12 +15,9 @@ #define SOUP_IS_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SOCKET)) #define SOUP_SOCKET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOCKET, SoupSocketClass)) -typedef struct SoupSocketPrivate SoupSocketPrivate; - struct SoupSocket { GObject parent; - SoupSocketPrivate *priv; }; typedef struct { diff --git a/libsoup/soup-types.h b/libsoup/soup-types.h index c7a97aa..ecd7282 100644 --- a/libsoup/soup-types.h +++ b/libsoup/soup-types.h @@ -25,30 +25,6 @@ typedef struct SoupSessionSync SoupSessionSync; typedef struct SoupSocket SoupSocket; typedef struct SoupUri SoupUri; -#define SOUP_MAKE_TYPE(type_name,TypeName,class_init,init,parent) \ -GType type_name##_get_type(void)\ -{\ - static GType type = 0; \ - if (!type){ \ - static GTypeInfo const object_info = { \ - sizeof (TypeName##Class), \ - \ - (GBaseInitFunc) NULL, \ - (GBaseFinalizeFunc) NULL, \ - \ - (GClassInitFunc) class_init, \ - (GClassFinalizeFunc) NULL, \ - NULL, /* class_data */ \ - \ - sizeof (TypeName), \ - 0, /* n_preallocs */ \ - (GInstanceInitFunc) init, \ - }; \ - type = g_type_register_static (parent, #TypeName, &object_info, 0); \ - } \ - return type; \ -} - #define SOUP_MAKE_INTERFACE(type_name,TypeName,base_init) \ GType type_name##_get_type(void)\ {\ @@ -73,34 +49,4 @@ GType type_name##_get_type(void)\ return type; \ } -#define SOUP_MAKE_TYPE_WITH_IFACE(type_name,TypeName,class_init,init,parent,iface_init,iparent) \ -GType type_name##_get_type(void)\ -{\ - static GType type = 0; \ - if (!type){ \ - static GTypeInfo const object_info = { \ - sizeof (TypeName##Class), \ - \ - (GBaseInitFunc) NULL, \ - (GBaseFinalizeFunc) NULL, \ - \ - (GClassInitFunc) class_init, \ - (GClassFinalizeFunc) NULL, \ - NULL, /* class_data */ \ - \ - sizeof (TypeName), \ - 0, /* n_preallocs */ \ - (GInstanceInitFunc) init, \ - }; \ - static GInterfaceInfo const iface_info = { \ - (GInterfaceInitFunc) iface_init, \ - NULL, \ - NULL \ - }; \ - type = g_type_register_static (parent, #TypeName, &object_info, 0); \ - g_type_add_interface_static (type, iparent, &iface_info); \ - } \ - return type; \ -} - #endif diff --git a/tests/revserver.c b/tests/revserver.c index be6f6d9..a09b7bc 100644 --- a/tests/revserver.c +++ b/tests/revserver.c @@ -3,7 +3,6 @@ #endif #include -#include #include #include #include @@ -12,6 +11,8 @@ #include #include +#include + static void rev_read (SoupSocket *sock, GString *buf); static void rev_write (SoupSocket *sock, GString *buf); @@ -117,15 +118,18 @@ start_thread (void *client) static void new_connection (SoupSocket *listener, SoupSocket *client, gpointer user_data) { - pthread_t pth; + GThread *thread; + GError *error = NULL; g_object_ref (client); g_object_set (G_OBJECT (client), SOUP_SOCKET_FLAG_NONBLOCKING, FALSE, NULL); - if (pthread_create (&pth, NULL, start_thread, client) != 0) { - g_warning ("Could not start thread"); + thread = g_thread_create (start_thread, client, FALSE, &error); + if (thread == NULL) { + g_warning ("Could not start thread: %s", error->message); + g_error_free (error); g_object_unref (client); } } @@ -141,6 +145,7 @@ main (int argc, char **argv) int opt; g_type_init (); + g_thread_init (NULL); while ((opt = getopt (argc, argv, "6p:")) != -1) { switch (opt) { -- 2.7.4