2005-04-11 Dan Winship <danw@novell.com>
+ * 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 <danw@novell.com>
+
* configure.in: bump version to 2.3.0. bump SOUP_API_VERSION to
2.4
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)
#define INADDR_NONE -1
#endif
-struct SoupAddressPrivate {
+typedef struct {
struct sockaddr *sockaddr;
char *name, *physical;
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)
/* 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 {
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;
G_TYPE_INT);
}
-SOUP_MAKE_TYPE (soup_address, SoupAddress, class_init, init, PARENT_TYPE)
-
-
/**
* soup_address_new:
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;
}
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;
}
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;
}
{
g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
- return addr->priv->name;
+ return SOUP_ADDRESS_GET_PRIVATE (addr)->name;
}
/**
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;
}
/**
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;
}
/**
{
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;
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;
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);
}
/**
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);
#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 {
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";
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");
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);
}
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;
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);
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);
}
#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 {
ALGORITHM_MD5_SESS = 1 << 1
} AlgorithmType;
-struct SoupAuthDigestPrivate {
+typedef struct {
char *user;
guchar hex_a1[33];
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";
object_class->finalize = finalize;
}
-SOUP_MAKE_TYPE (soup_auth_digest, SoupAuthDigest, class_init, init, PARENT_TYPE)
-
typedef struct {
char *name;
guint type;
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;
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;
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 == ',')
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);
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);
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
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;
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);
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];
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);
/* 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 ();
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;
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);
g_free (url);
g_free (nc);
- digest->priv->nc++;
+ priv->nc++;
return out;
}
#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 {
#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;
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,
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;
}
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;
}
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
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,
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,
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);
}
#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 {
#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
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,
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,
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;
G_PARAM_READWRITE));
}
-SOUP_MAKE_TYPE (soup_connection, SoupConnection, class_init, init, PARENT_TYPE)
-
/**
* soup_connection_new:
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;
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;
}
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
}
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)
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)) {
}
g_signal_emit (conn, signals[CONNECT_RESULT], 0,
- proxified_status (conn, status));
+ proxified_status (priv, status));
g_object_unref (msg);
}
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;
}
/* 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);
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));
}
/**
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);
}
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;
}
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;
}
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
* 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.
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
- return conn->priv->in_use;
+ return SOUP_CONNECTION_GET_PRIVATE (conn)->in_use;
}
/**
{
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
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);
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);
}
/**
{
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);
}
{
g_return_if_fail (SOUP_IS_CONNECTION (conn));
- conn->priv->in_use = TRUE;
+ SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = TRUE;
}
/**
{
g_return_if_fail (SOUP_IS_CONNECTION (conn));
- conn->priv->in_use = FALSE;
+ SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = FALSE;
}
/**
#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 {
guint *content_len,
gpointer user_data)
{
+ SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req);
const char *length, *enc;
SoupHttpVersion version;
GHashTable *resp_hdrs;
(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;
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;
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 {
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;
}
/**
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);
guint status_code,
SoupStatusClass status_class)
{
+ SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupHandlerData *data;
data = g_new0 (SoupHandlerData, 1);
break;
}
- msg->priv->content_handlers =
- g_slist_append (msg->priv->content_handlers, data);
+ priv->content_handlers =
+ g_slist_append (priv->content_handlers, data);
}
/**
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;
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;
*/
#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;
g_string_free (io->write_buf, TRUE);
g_free (io);
- msg->priv->io_data = NULL;
+ priv->io_data = NULL;
}
/**
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;
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 &&
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);
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);
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;
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) {
*/
}
} 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;
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:
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;
SoupMessageParseHeadersFn parse_headers_cb,
gpointer user_data)
{
+ SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io;
io = g_new0 (SoupMessageIOData, 1);
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);
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;
}
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);
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);
#include <libsoup/soup-message.h>
-struct SoupMessagePrivate {
+typedef struct {
gpointer io_data;
guint msg_flags;
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);
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;
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,
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);
#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,
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,
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);
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;
G_TYPE_NONE, 0);
}
-SOUP_MAKE_TYPE (soup_message, SoupMessage, class_init, init, PARENT_TYPE)
-
/**
* soup_message_new:
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;
}
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;
}
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- msg->priv->msg_flags = flags;
+ SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags = flags;
}
/**
{
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), 0);
- return msg->priv->msg_flags;
+ return SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags;
}
/**
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- msg->priv->http_version = version;
+ SOUP_MESSAGE_GET_PRIVATE (msg)->http_version = version;
}
/**
{
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;
}
/**
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.
*/
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);
}
/**
{
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
- return msg->priv->uri;
+ return SOUP_MESSAGE_GET_PRIVATE (msg)->uri;
}
/**
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);
}
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);
}
}
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;
}
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)
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;
}
#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,
struct SoupMessage {
GObject parent;
- SoupMessagePrivate *priv;
-
const char *method;
guint status_code;
#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
/* 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)
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;
}
{
g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), NULL);
- return smsg->priv->server;
+ return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->server;
}
void
{
g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg));
- smsg->priv->encoding = encoding;
+ SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->encoding = encoding;
}
SoupTransferEncoding
{
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
{
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));
}
{
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));
}
{
g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), TRUE);
- return smsg->priv->finished;
+ return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->finished;
}
#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 {
#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;
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,
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
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;
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:
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;
soup_server_new (const char *optname1, ...)
{
SoupServer *server;
+ SoupServerPrivate *priv;
va_list ap;
va_start (ap, 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;
}
/* 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;
}
{
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;
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);
}
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);
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);
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);
}
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;
}
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);
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;
g_free (mypath);
- return server->priv->default_handler;
+ return priv->default_handler;
}
SoupAddress *
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);
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);
}
}
#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 {
#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,
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)
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);
}
#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 {
#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,
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;
object_class->finalize = finalize;
}
-SOUP_MAKE_TYPE (soup_session_sync, SoupSessionSync, class_init, init, PARENT_TYPE)
SoupSession *
soup_session_sync_new (void)
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,
}
}
- g_mutex_unlock (ss->priv->lock);
+ g_mutex_unlock (priv->lock);
return conn;
}
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;
}
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 */
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;
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);
}
#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 {
GHashTable *auths; /* scheme:realm -> SoupAuth */
} SoupSessionHost;
-struct SoupSessionPrivate {
+typedef struct {
SoupUri *proxy_uri;
guint max_conns, max_conns_per_host;
gboolean use_ntlm;
* 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);
#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,
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,
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;
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
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)
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;
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;
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;
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);
}
/**
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);
}
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;
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;
}
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
}
static void
-free_host (SoupSessionHost *host, SoupSession *session)
+free_host (SoupSessionHost *host)
{
while (host->connections) {
SoupConnection *conn = host->connections->data;
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);
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);
}
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,
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;
}
}
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);
}
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) {
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;
}
/* 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",
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
*/
msg->status = SOUP_MESSAGE_STATUS_CONNECTING;
- g_mutex_unlock (session->priv->host_lock);
+ g_mutex_unlock (priv->host_lock);
*is_new = TRUE;
return conn;
}
#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;
};
#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;
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;
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;
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");
}
/**
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;
}
/**
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);
}
/**
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;
}
/**
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);
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);
}
/**
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);
}
/**
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");
}
/**
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);
}
/**
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);
}
/**
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);
}
/**
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");
}
/**
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);
}
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);
}
/**
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);
}
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);
}
/**
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;
}
/**
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",
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;
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;
}
/**
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);
#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 {
#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;
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:
}
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);
}
}
}
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;
}
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;
}
/* 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;
}
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;
}
/**
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);
}
/**
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;
}
/**
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;
}
/**
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))
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;
#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 {
#include <netinet/in.h>
#include <netinet/tcp.h>
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupSocket, soup_socket, G_TYPE_OBJECT)
enum {
CONNECT_RESULT,
LAST_PROP
};
-struct SoupSocketPrivate {
+typedef struct {
int sockfd;
SoupAddress *local_addr, *remote_addr;
GIOChannel *iochannel;
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
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;
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));
}
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;
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;
}
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;
}
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)
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);
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);
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);
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;
}
}
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);
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.
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;
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));
}
/**
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;
}
gpointer ssl_creds, guint *status_ret)
{
SoupSocket *sock;
+ SoupSocketPrivate *priv;
guint status;
g_return_val_if_fail (hostname != NULL, NULL);
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)) {
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;
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;
* 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);
}
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;
}
/**
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;
}
/**
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;
}
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;
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 &&
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;
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);
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;
}
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;
read_buf->len = prev_len + *nread;
if (status != SOUP_SOCKET_OK) {
- g_mutex_unlock (sock->priv->iolock);
+ g_mutex_unlock (priv->iolock);
return status;
}
}
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;
}
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;
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) {
}
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;
}
#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 {
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)\
{\
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
#endif
#include <ctype.h>
-#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libsoup/soup-address.h>
#include <libsoup/soup-socket.h>
+#include <glib/gthread.h>
+
static void rev_read (SoupSocket *sock, GString *buf);
static void rev_write (SoupSocket *sock, GString *buf);
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);
}
}
int opt;
g_type_init ();
+ g_thread_init (NULL);
while ((opt = getopt (argc, argv, "6p:")) != -1) {
switch (opt) {
projects / platform / upstream / libsoup.git / commitdiff