/**
* im_channel_closed_cb:
*
* Signal callback for when an IM channel is closed. Removes the references
* that #GabbleConnection holds to them - unless the channel has pending
* messages, in which case it is re-announced (so from the perspective of the
* D-Bus API, it was replaced by an identical channel).
*/
static void
im_channel_closed_cb (GabbleIMChannel *chan, gpointer user_data)
{
GabbleImFactory *self = GABBLE_IM_FACTORY (user_data);
GabbleImFactoryPrivate *priv = self->priv;
TpBaseChannel *base = TP_BASE_CHANNEL (chan);
TpHandle contact_handle = tp_base_channel_get_target_handle (base);
DEBUG ("%p, channel %p", self, chan);
if (tp_base_channel_is_registered (base))
{
tp_channel_manager_emit_channel_closed_for_object (self,
(TpExportableChannel *) chan);
}
if (priv->channels != NULL)
{
if (tp_base_channel_is_destroyed (base))
{
DEBUG ("removing channel with handle %u", contact_handle);
g_hash_table_remove (priv->channels,
GUINT_TO_POINTER (contact_handle));
}
else if (tp_base_channel_is_respawning (base))
{
DEBUG ("reopening channel with handle %u due to pending messages",
contact_handle);
tp_channel_manager_emit_new_channel (self,
(TpExportableChannel *) chan, NULL);
}
else
{
/* this basically means tp_base_channel_disappear() must
* have been called; this doesn't have any meaning in this
* channel manager. */
g_assert_not_reached ();
}
}
}
static void
gabble_auth_manager_start_auth_async (WockyAuthRegistry *registry,
const GSList *mechanisms,
gboolean allow_plain,
gboolean is_secure_channel,
const gchar *username,
const gchar *password,
const gchar *server,
const gchar *session_id,
GAsyncReadyCallback callback,
gpointer user_data)
{
GabbleAuthManager *self = GABBLE_AUTH_MANAGER (registry);
/* assumption: Wocky's API guarantees that we never have more than one
* auth request outstanding */
g_assert (self->priv->channel == NULL);
if (password == NULL || username == NULL)
{
GPtrArray *mech_array = g_ptr_array_new ();
const GSList *iter;
for (iter = mechanisms; iter != NULL; iter = iter->next)
{
self->priv->mechanisms = g_slist_prepend (self->priv->mechanisms,
g_strdup (iter->data));
/* skip Wocky-specific pseudo-mechanisms for the D-Bus API */
if (!g_str_has_prefix (iter->data, "X-WOCKY-JABBER-"))
g_ptr_array_add (mech_array, iter->data);
}
if (wocky_auth_registry_supports_one_of (registry, mechanisms,
allow_plain))
g_ptr_array_add (mech_array, X_TELEPATHY_PASSWORD);
g_ptr_array_add (mech_array, NULL);
/* we'll use these if we fall back to the base class to use
* X-TELEPATHY-PASSWORD */
self->priv->mechanisms = g_slist_reverse (self->priv->mechanisms);
self->priv->allow_plain = allow_plain;
self->priv->is_secure_channel = is_secure_channel;
self->priv->server = g_strdup (server);
self->priv->session_id = g_strdup (session_id);
if (username == NULL)
{
g_object_get (self->priv->conn,
"username", &self->priv->username,
NULL);
}
else
{
self->priv->username = g_strdup (username);
}
self->priv->channel = gabble_server_sasl_channel_new (self->priv->conn,
(GStrv) mech_array->pdata, is_secure_channel, session_id);
g_ptr_array_unref (mech_array);
self->priv->closed_id = tp_g_signal_connect_object (self->priv->channel,
"closed", G_CALLBACK (auth_channel_closed_cb), self, 0);
gabble_server_sasl_channel_start_auth_async (self->priv->channel,
gabble_auth_manager_start_auth_cb,
g_simple_async_result_new ((GObject *) self,
callback, user_data, gabble_auth_manager_start_auth_async));
g_assert (!tp_base_channel_is_destroyed (
(TpBaseChannel *) self->priv->channel));
g_assert (tp_base_channel_is_registered (
(TpBaseChannel *) self->priv->channel));
tp_channel_manager_emit_new_channel (self,
TP_EXPORTABLE_CHANNEL (self->priv->channel), NULL);
}
else
{
WOCKY_AUTH_REGISTRY_CLASS (
gabble_auth_manager_parent_class)->start_auth_async_func (
registry, mechanisms, allow_plain, is_secure_channel,
username, password, server, session_id, callback, user_data);
}
}