/* Make sure google knows we want mail notifications. According to
* Google clients should set 'mailnotifications' to true when needed
* but never to false, for compatibility reasons:
* https://code.google.com/apis/talk/jep_extensions/usersettings.html#3 */
static void
ensure_google_settings (GabbleConnection *self)
{
TpBaseConnection *base_conn = TP_BASE_CONNECTION (self);
WockyStanza *query;
WockyPorter *porter;
if (!self->mail_priv->should_set_google_settings)
return;
if (base_conn->status != TP_CONNECTION_STATUS_CONNECTED)
return;
porter = wocky_session_get_porter (self->session);
query = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_SET, NULL, NULL,
'@', "id", "user-setting-3",
'(', "usersetting",
':', NS_GOOGLE_SETTING,
'(', "mailnotifications",
'@', "value", "true",
')',
')',
NULL);
wocky_porter_send_iq_async (porter, query, NULL,
set_settings_cb, self);
self->mail_priv->should_set_google_settings = FALSE;
g_object_unref (query);
}
static void
update_unread_mails (GabbleConnection *conn)
{
TpBaseConnection *base_conn = TP_BASE_CONNECTION (conn);
WockyStanza *query;
WockyPorter *porter = wocky_session_get_porter (conn->session);
if (base_conn->status != TP_CONNECTION_STATUS_CONNECTED)
return;
if (!(conn->features & GABBLE_CONNECTION_FEATURES_GOOGLE_MAIL_NOTIFY))
return;
DEBUG ("Updating unread mails information");
query = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_GET, NULL, NULL,
'(', "query",
':', NS_GOOGLE_MAIL_NOTIFY,
')',
NULL);
wocky_porter_send_iq_async (porter, query, NULL,
query_unread_mails_cb, conn);
g_object_unref (query);
}
/* resume control after the sasl auth server is done: */
static void
after_auth (GObject *source,
GAsyncResult *res,
gpointer data)
{
GError *error = NULL;
WockyStanza *feat = NULL;
WockyNode *node = NULL;
TestSaslAuthServer *tsas = TEST_SASL_AUTH_SERVER (source);
TestConnectorServer *tcs = TEST_CONNECTOR_SERVER (data);
TestConnectorServerPrivate *priv = tcs->priv;
WockyXmppConnection *conn = priv->conn;
DEBUG ("Auth finished: %d", priv->outstanding);
if (!test_sasl_auth_server_auth_finish (tsas, res, &error))
{
g_object_unref (priv->sasl);
priv->sasl = NULL;
if (server_dec_outstanding (tcs))
return;
server_enc_outstanding (tcs);
wocky_xmpp_connection_send_close_async (conn, priv->cancellable,
xmpp_close, data);
return;
}
priv->used_mech = g_strdup (test_sasl_auth_server_get_selected_mech
(priv->sasl));
g_object_unref (priv->sasl);
priv->sasl = NULL;
if (server_dec_outstanding (tcs))
return;
feat = wocky_stanza_build (WOCKY_STANZA_TYPE_STREAM_FEATURES,
WOCKY_STANZA_SUB_TYPE_NONE, NULL, NULL, NULL);
node = wocky_stanza_get_top_node (feat);
if (!(priv->problem.connector->xmpp & XMPP_PROBLEM_NO_SESSION))
wocky_node_add_child_ns (node, "session", WOCKY_XMPP_NS_SESSION);
if (!(priv->problem.connector->xmpp & XMPP_PROBLEM_CANNOT_BIND))
wocky_node_add_child_ns (node, "bind", WOCKY_XMPP_NS_BIND);
priv->state = SERVER_STATE_FEATURES_SENT;
server_enc_outstanding (tcs);
wocky_xmpp_connection_send_stanza_async (conn, feat, priv->cancellable,
xmpp_init, data);
g_object_unref (feat);
}
void
gabble_jingle_info_send_request (GabbleJingleInfo *self)
{
GabbleJingleInfoPrivate *priv = self->priv;
WockyStanza *stanza = wocky_stanza_build (
WOCKY_STANZA_TYPE_IQ, WOCKY_STANZA_SUB_TYPE_GET, NULL,
wocky_porter_get_bare_jid (priv->porter),
'(', "query", ':', NS_GOOGLE_JINGLE_INFO, ')', NULL);
wocky_porter_send_iq_async (priv->porter, stanza, NULL, jingle_info_reply_cb,
g_object_ref (self));
g_object_unref (stanza);
}
static void
google_queueing_send_command (
GabbleConnection *conn,
const gchar *command,
GAsyncReadyCallback callback,
gpointer user_data)
{
WockyStanza *stanza = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_SET, NULL, NULL,
'(', "query",
':', NS_GOOGLE_QUEUE,
'(', command, ')',
')',
NULL);
conn_util_send_iq_async (conn, stanza, NULL, callback, user_data);
g_object_unref (stanza);
}
static void
iq_set_session_XMPP_SESSION (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
SessionProblem problems = priv->problem.connector->session;
SessionProblem sp = SESSION_PROBLEM_NONE;
DEBUG ("");
if ((sp = problems & SESSION_PROBLEM_FAILED) ||
(sp = problems & SESSION_PROBLEM_DENIED) ||
(sp = problems & SESSION_PROBLEM_CONFLICT) ||
(sp = problems & SESSION_PROBLEM_REJECTED))
{
const gchar *error = NULL;
const gchar *etype = NULL;
switch (sp)
{
case SESSION_PROBLEM_FAILED:
error = "internal-server-error";
etype = "wait";
break;
case SESSION_PROBLEM_DENIED:
error = "forbidden";
etype = "auth";
break;
case SESSION_PROBLEM_CONFLICT:
error = "conflict";
etype = "cancel";
break;
default:
error = "snaaaaake";
etype = "mushroom";
break;
}
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'(', "session", ':', WOCKY_XMPP_NS_SESSION,
')',
'(', "error", '@', "type", etype,
'(', error, ':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (problems & SESSION_PROBLEM_NO_SESSION)
{
iq = error_stanza ("resource-constraint", "Out of Cheese Error", FALSE);
}
else if (problems & SESSION_PROBLEM_NONSENSE)
{
/* deliberately nonsensical response */
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_MESSAGE,
WOCKY_STANZA_SUB_TYPE_NONE,
NULL, NULL,
'(', "surstromming", ':', WOCKY_XMPP_NS_BIND,
')',
NULL);
}
else
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'(', "session", ':', WOCKY_XMPP_NS_SESSION,
')',
NULL);
}
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq, NULL, iq_sent, self);
g_object_unref (xml);
g_object_unref (iq);
}
static void
iq_set_bind_XMPP_BIND (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
BindProblem problems = priv->problem.connector->bind;
BindProblem bp = BIND_PROBLEM_NONE;
DEBUG("");
if ((bp = problems & BIND_PROBLEM_INVALID) ||
(bp = problems & BIND_PROBLEM_DENIED) ||
(bp = problems & BIND_PROBLEM_CONFLICT) ||
(bp = problems & BIND_PROBLEM_REJECTED))
{
const gchar *error = NULL;
const gchar *etype = NULL;
switch (bp)
{
case BIND_PROBLEM_INVALID:
error = "bad-request";
etype = "modify";
break;
case BIND_PROBLEM_DENIED:
error = "not-allowed";
etype = "cancel";
break;
case BIND_PROBLEM_CONFLICT:
error = "conflict";
etype = "cancel";
break;
default:
error = "badger-badger-badger-mushroom";
etype = "moomins";
}
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'(', "bind", ':', WOCKY_XMPP_NS_BIND,
')',
'(', "error", '@', "type", etype,
'(', error, ':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (problems & BIND_PROBLEM_FAILED)
{
/* deliberately nonsensical response */
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_SET,
NULL, NULL,
'(', "bind", ':', WOCKY_XMPP_NS_BIND,
')',
NULL);
}
else if (problems & BIND_PROBLEM_NONSENSE)
{
/* deliberately nonsensical response */
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_MESSAGE,
WOCKY_STANZA_SUB_TYPE_NONE,
NULL, NULL,
'(', "bind", ':', WOCKY_XMPP_NS_BIND,
')',
NULL);
}
else if (problems & BIND_PROBLEM_CLASH)
{
iq = error_stanza ("conflict", NULL, FALSE);
}
else
{
WockyNode *ciq = wocky_stanza_get_top_node (xml);
WockyNode *bind =
wocky_node_get_child_ns (ciq, "bind", WOCKY_XMPP_NS_BIND);
WockyNode *res = wocky_node_get_child (bind, "resource");
const gchar *uniq = NULL;
gchar *jid = NULL;
if (res != NULL)
uniq = res->content;
if (uniq == NULL)
uniq = "a-made-up-resource";
if (problems & BIND_PROBLEM_NO_JID)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT, NULL, NULL,
'(', "bind", ':', WOCKY_XMPP_NS_BIND,
')', NULL);
}
else
{
jid = g_strdup_printf ("[email protected]/%s", uniq);
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'(', "bind", ':', WOCKY_XMPP_NS_BIND,
'(', "jid", '$', jid, ')',
')',
NULL);
g_free (jid);
}
}
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq, priv->cancellable,
iq_sent, self);
g_object_unref (xml);
g_object_unref (iq);
}
static void
iq_set_query_JABBER_AUTH (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
WockyNode *env = wocky_stanza_get_top_node (xml);
WockyNode *qry = wocky_node_get_child (env, "query");
JabberProblem problems = priv->problem.connector->jabber;
JabberProblem jp = JABBER_PROBLEM_NONE;
WockyNode *username = wocky_node_get_child (qry, "username");
WockyNode *password = wocky_node_get_child (qry, "password");
WockyNode *resource = wocky_node_get_child (qry, "resource");
WockyNode *sha1hash = wocky_node_get_child (qry, "digest");
const gchar *id = wocky_node_get_attribute (env, "id");
DEBUG ("");
if (username == NULL || resource == NULL)
problems |= JABBER_PROBLEM_AUTH_PARTIAL;
else if (password != NULL)
{
if (wocky_strdiff (priv->user, username->content) ||
wocky_strdiff (priv->pass, password->content))
problems |= JABBER_PROBLEM_AUTH_REJECT;
}
else if (sha1hash != NULL)
{
gchar *hsrc = g_strconcat (INITIAL_STREAM_ID, priv->pass, NULL);
gchar *sha1 = g_compute_checksum_for_string (G_CHECKSUM_SHA1, hsrc, -1);
DEBUG ("checksum: %s vs %s", sha1, sha1hash->content);
if (wocky_strdiff (priv->user, username->content) ||
wocky_strdiff (sha1, sha1hash->content))
problems |= JABBER_PROBLEM_AUTH_REJECT;
g_free (hsrc);
g_free (sha1);
}
else
problems |= JABBER_PROBLEM_AUTH_PARTIAL;
if ((jp = problems & JABBER_PROBLEM_AUTH_REJECT) ||
(jp = problems & JABBER_PROBLEM_AUTH_BIND) ||
(jp = problems & JABBER_PROBLEM_AUTH_PARTIAL) ||
(jp = problems & JABBER_PROBLEM_AUTH_FAILED))
{
const gchar *error = NULL;
const gchar *etype = NULL;
const gchar *ecode = NULL;
switch (jp)
{
case JABBER_PROBLEM_AUTH_REJECT:
error = "not-authorized";
etype = "auth";
ecode = "401";
break;
case JABBER_PROBLEM_AUTH_BIND:
error = "conflict";
etype = "cancel";
ecode = "409";
break;
case JABBER_PROBLEM_AUTH_PARTIAL:
error = "not-acceptable";
etype = "modify";
ecode = "406";
break;
default:
error = "bad-request";
etype = "modify";
ecode = "500";
break;
}
DEBUG ("error: %s/%s", error, etype);
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error",
'@', "type", etype,
'@', "code", ecode,
'(', error, ':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (problems & JABBER_PROBLEM_AUTH_STRANGE)
{
DEBUG ("auth WEIRD");
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_SET,
NULL, NULL,
'@', "id", id,
'(', "surstromming", ':', WOCKY_XMPP_NS_BIND,
')',
NULL);
}
else if (problems & JABBER_PROBLEM_AUTH_NONSENSE)
{
DEBUG ("auth NONSENSE");
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_MESSAGE,
WOCKY_STANZA_SUB_TYPE_NONE,
NULL, NULL,
'@', "id", id,
'(', "surstromming", ':', WOCKY_XMPP_NS_BIND,
')',
NULL);
}
else
{
DEBUG ("auth OK");
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
NULL);
}
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq, priv->cancellable,
iq_sent, self);
g_object_unref (iq);
g_object_unref (xml);
}
static void
iq_get_query_JABBER_AUTH (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
WockyNode *env = wocky_stanza_get_top_node (xml);
const gchar *id = wocky_node_get_attribute (env, "id");
WockyNode *query = wocky_node_get_child (env, "query");
WockyNode *user = (query != NULL) ?
wocky_node_get_child (query, "username") : NULL;
const gchar *name = (user != NULL) ? user->content : NULL;
DEBUG ("");
if (priv->problem.connector->jabber & JABBER_PROBLEM_AUTH_NIH)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error", '@', "type", "cancel",
'(', "service-unavailable",
':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (name == NULL || *name == '\0')
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error", '@', "type", "modify",
'(', "not-acceptable",
':', WOCKY_XMPP_NS_STANZAS,
')',
'(', "text", ':', WOCKY_XMPP_NS_STANZAS,
'$',
"You must include the username in the initial IQ get to work "
"around a bug in jabberd 1.4. See "
"https://bugs.freedesktop.org/show_bug.cgi?id=24013",
')',
')',
NULL);
}
else if (priv->mech != NULL)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
'(', "query", ':', WOCKY_JABBER_NS_AUTH,
'(', "username", ')',
'(', priv->mech, ')',
'(', "resource", ')',
')',
NULL);
}
else
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
'(', "query", ':', WOCKY_JABBER_NS_AUTH,
'(', "username", ')',
'(', "password", ')',
'(', "resource", ')',
'(', "digest", ')',
')',
NULL);
}
DEBUG ("responding to iq get");
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq,
priv->cancellable, iq_sent, self);
DEBUG ("sent iq get response");
g_object_unref (xml);
g_object_unref (iq);
}
static void
iq_get_query_XEP77_REGISTER (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
WockyNode *env = wocky_stanza_get_top_node (xml);
WockyNode *query = NULL;
const gchar *id = wocky_node_get_attribute (env, "id");
DEBUG ("");
if (priv->problem.connector->xep77 & XEP77_PROBLEM_NOT_AVAILABLE)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error", '@', "type", "cancel",
'(', "service-unavailable",
':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (priv->problem.connector->xep77 & XEP77_PROBLEM_QUERY_NONSENSE)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_MESSAGE,
WOCKY_STANZA_SUB_TYPE_NONE,
NULL, NULL,
'@', "id", id,
'(', "plankton", ':', WOCKY_XEP77_NS_REGISTER,
')',
NULL);
}
else if (priv->problem.connector->xep77 & XEP77_PROBLEM_QUERY_ALREADY)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
'(', "query", ':', WOCKY_XEP77_NS_REGISTER,
'(', "registered", ')',
'(', "username", '$', "foo", ')',
'(', "password", '$', "bar", ')',
')',
NULL);
}
else
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
'(', "query", ':', WOCKY_XEP77_NS_REGISTER,
'*', &query,
')',
NULL);
if (!(priv->problem.connector->xep77 & XEP77_PROBLEM_NO_ARGS))
{
wocky_node_add_child (query, "username");
wocky_node_add_child (query, "password");
if (priv->problem.connector->xep77 & XEP77_PROBLEM_EMAIL_ARG)
wocky_node_add_child (query, "email");
if (priv->problem.connector->xep77 & XEP77_PROBLEM_STRANGE_ARG)
wocky_node_add_child (query, "wildebeest");
}
}
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq, NULL, iq_sent, self);
g_object_unref (xml);
g_object_unref (iq);
}
/* ************************************************************************* */
static void
iq_set_query_XEP77_REGISTER (TestConnectorServer *self,
WockyStanza *xml)
{
TestConnectorServerPrivate *priv = self->priv;
WockyXmppConnection *conn = priv->conn;
WockyStanza *iq = NULL;
WockyNode *env = wocky_stanza_get_top_node (xml);
WockyNode *query = wocky_node_get_child (env, "query");
const gchar *id = wocky_node_get_attribute (env, "id");
gpointer cb = iq_sent;
DEBUG ("");
if (priv->problem.connector->xep77 & XEP77_PROBLEM_ALREADY)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
'(', "query", ':', WOCKY_XEP77_NS_REGISTER,
'(', "registered", ')',
'(', "username", '$', "foo", ')',
'(', "password", '$', "bar", ')',
')',
NULL);
}
else if (priv->problem.connector->xep77 & XEP77_PROBLEM_FAIL_CONFLICT)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error", '@', "type", "cancel",
'(', "conflict",
':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else if (priv->problem.connector->xep77 & XEP77_PROBLEM_FAIL_REJECTED)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error", '@', "type", "modify",
'(', "not-acceptable",
':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else
{
if (wocky_node_get_child (query, "remove") == NULL)
{
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
NULL);
}
else
{
XEP77Problem problem = priv->problem.connector->xep77;
XEP77Problem p = XEP77_PROBLEM_NONE;
DEBUG ("handling CANCEL");
if ((p = problem & XEP77_PROBLEM_CANCEL_REJECTED) ||
(p = problem & XEP77_PROBLEM_CANCEL_DISABLED) ||
(p = problem & XEP77_PROBLEM_CANCEL_FAILED))
{
const gchar *error = NULL;
const gchar *etype = NULL;
const gchar *ecode = NULL;
switch (p)
{
case XEP77_PROBLEM_CANCEL_REJECTED:
error = "bad-request";
etype = "modify";
ecode = "400";
break;
case XEP77_PROBLEM_CANCEL_DISABLED:
error = "not-allowed";
etype = "cancel";
ecode = "405";
break;
default:
error = "forbidden";
etype = "cancel";
ecode = "401";
}
DEBUG ("error: %s/%s", error, etype);
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_ERROR,
NULL, NULL,
'@', "id", id,
'(', "error",
'@', "type", etype,
'@', "code", ecode,
'(', error, ':', WOCKY_XMPP_NS_STANZAS,
')',
')',
NULL);
}
else
{
if (priv->problem.connector->xep77 & XEP77_PROBLEM_CANCEL_STREAM)
{
iq = error_stanza ("not-authorized", NULL, FALSE);
cb = finished;
}
else
{
cb = iq_sent_unregistered;
iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ,
WOCKY_STANZA_SUB_TYPE_RESULT,
NULL, NULL,
'@', "id", id,
NULL);
}
}
}
}
server_enc_outstanding (self);
wocky_xmpp_connection_send_stanza_async (conn, iq,
priv->cancellable, cb, self);
g_object_unref (xml);
g_object_unref (iq);
}
