static void
xmpp_handler (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TestConnectorServer *self;
TestConnectorServerPrivate *priv;
WockyStanza *xml = NULL;
WockyXmppConnection *conn = NULL;
const gchar *ns = NULL;
const gchar *name = NULL;
gboolean handled = FALSE;
GError *error = NULL;
WockyStanzaType type = WOCKY_STANZA_TYPE_NONE;
WockyStanzaSubType subtype = WOCKY_STANZA_SUB_TYPE_NONE;
int i;
DEBUG ("");
self = TEST_CONNECTOR_SERVER (user_data);
priv = self->priv;
conn = priv->conn;
xml = wocky_xmpp_connection_recv_stanza_finish (conn, result, &error);
/* A real XMPP server would need to do some error handling here, but if
* we got this far, we can just exit: The client (ie the test) will
* report any error that actually needs reporting - we don't need to */
if (error != NULL)
{
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
g_error_free (error);
server_dec_outstanding (self);
return;
}
g_assert_not_reached ();
}
if (server_dec_outstanding (self))
return;
ns = wocky_node_get_ns (wocky_stanza_get_top_node (xml));
name = wocky_stanza_get_top_node (xml)->name;
wocky_stanza_get_type_info (xml, &type, &subtype);
/* if we find a handler, the handler is responsible for listening for the
next stanza and setting up the next callback in the chain: */
if (type == WOCKY_STANZA_TYPE_IQ)
for (i = 0; iq_handlers[i].payload != NULL; i++)
{
iq_handler *iq = &iq_handlers[i];
WockyNode *payload =
wocky_node_get_child_ns (wocky_stanza_get_top_node (xml),
iq->payload, iq->ns);
/* namespace, stanza subtype and payload tag name must match: */
if ((payload == NULL) || (subtype != iq->subtype))
continue;
DEBUG ("test_connector_server:invoking iq handler %s", iq->payload);
(iq->func) (self, xml);
handled = TRUE;
break;
}
else
for (i = 0; handlers[i].ns != NULL; i++)
{
if (!strcmp (ns, handlers[i].ns) && !strcmp (name, handlers[i].name))
{
DEBUG ("test_connector_server:invoking handler %s.%s", ns, name);
(handlers[i].func) (self, xml);
handled = TRUE;
break;
}
}
/* no handler found: just complain and sit waiting for the next stanza */
if (!handled)
{
DEBUG ("<%s xmlns=\"%s\"… not handled", name, ns);
server_enc_outstanding (self);
wocky_xmpp_connection_recv_stanza_async (conn, priv->cancellable,
xmpp_handler, self);
g_object_unref (xml);
}
}
void
gabble_jingle_content_parse_add (GabbleJingleContent *c,
WockyNode *content_node, gboolean google_mode, GError **error)
{
GabbleJingleContentPrivate *priv = c->priv;
const gchar *name, *creator, *senders, *disposition;
WockyNode *trans_node, *desc_node;
GType transport_type = 0;
GabbleJingleTransportIface *trans = NULL;
JingleDialect dialect = gabble_jingle_session_get_dialect (c->session);
priv->created_by_us = FALSE;
desc_node = wocky_node_get_child (content_node, "description");
trans_node = wocky_node_get_child (content_node, "transport");
creator = wocky_node_get_attribute (content_node, "creator");
name = wocky_node_get_attribute (content_node, "name");
senders = wocky_node_get_attribute (content_node, "senders");
g_assert (priv->transport_ns == NULL);
if (google_mode)
{
if (creator == NULL)
creator = "initiator";
/* the google protocols don't give the contents names, so put in a dummy
* value if none was set by the session*/
if (priv->name == NULL)
name = priv->name = g_strdup ("gtalk");
else
name = priv->name;
if (trans_node == NULL)
{
/* gtalk lj0.3 assumes google-p2p transport */
DEBUG ("detected GTalk3 dialect");
dialect = JINGLE_DIALECT_GTALK3;
g_object_set (c->session, "dialect", JINGLE_DIALECT_GTALK3, NULL);
transport_type = gabble_jingle_factory_lookup_transport (
gabble_jingle_session_get_factory (c->session),
"");
/* in practice we do support gtalk-p2p, so this can't happen */
if (G_UNLIKELY (transport_type == 0))
{
SET_BAD_REQ ("gtalk-p2p transport unsupported");
return;
}
priv->transport_ns = g_strdup ("");
}
}
else
{
if (creator == NULL &&
gabble_jingle_session_peer_has_cap (c->session,
QUIRK_GOOGLE_WEBMAIL_CLIENT))
{
if (gabble_jingle_content_creator_is_initiator (c))
creator = "initiator";
else
creator = "responder";
DEBUG ("Working around GMail omitting creator=''; assuming '%s'",
creator);
}
if ((trans_node == NULL) || (creator == NULL) || (name == NULL))
{
SET_BAD_REQ ("missing required content attributes or elements");
return;
}
/* In proper protocols the name comes from the stanza */
g_assert (priv->name == NULL);
priv->name = g_strdup (name);
}
/* if we didn't set it to google-p2p implicitly already, detect it */
if (transport_type == 0)
{
const gchar *ns = wocky_node_get_ns (trans_node);
transport_type = gabble_jingle_factory_lookup_transport (
gabble_jingle_session_get_factory (c->session), ns);
if (transport_type == 0)
{
SET_BAD_REQ ("unsupported content transport");
return;
}
priv->transport_ns = g_strdup (ns);
}
if (senders == NULL)
priv->senders = get_default_senders (c);
else
priv->senders = parse_senders (senders);
if (priv->senders == JINGLE_CONTENT_SENDERS_NONE)
{
SET_BAD_REQ ("invalid content senders");
return;
}
parse_description (c, desc_node, error);
if (*error != NULL)
return;
disposition = wocky_node_get_attribute (content_node, "disposition");
if (disposition == NULL)
disposition = "session";
if (wocky_strdiff (disposition, priv->disposition))
{
g_free (priv->disposition);
priv->disposition = g_strdup (disposition);
}
DEBUG ("content creating new transport type %s", g_type_name (transport_type));
trans = gabble_jingle_transport_iface_new (transport_type,
c, priv->transport_ns);
g_signal_connect (trans, "new-candidates",
(GCallback) new_transport_candidates_cb, c);
/* Depending on transport, there may be initial candidates specified here */
if (trans_node != NULL)
{
gabble_jingle_transport_iface_parse_candidates (trans, trans_node, error);
if (*error)
{
g_object_unref (trans);
return;
}
}
g_assert (priv->transport == NULL);
priv->transport = trans;
transport_created (c);
g_assert (priv->creator == NULL);
priv->creator = g_strdup (creator);
priv->state = JINGLE_CONTENT_STATE_NEW;
/* GTalk4 seems to require "transport-accept" for acknowledging
* the transport type. wjt confirms that this is apparently necessary for
* incoming calls to work.
*/
if (dialect == JINGLE_DIALECT_GTALK4)
priv->gtalk4_event_id = g_idle_add (send_gtalk4_transport_accept, c);
return;
}
