void gabble_server_sasl_channel_challenge_async (GabbleServerSaslChannel *self, const GString *challenge_data, GAsyncReadyCallback callback, gpointer user_data) { GabbleServerSaslChannelPrivate *priv = self->priv; GArray *challenge_ay; g_assert (!tp_base_channel_is_destroyed ((TpBaseChannel *) self)); g_assert (priv->result == NULL); g_assert (priv->sasl_status == TP_SASL_STATUS_IN_PROGRESS); /* it might be sensitive, and also might not be UTF-8 text, so just print * the length */ DEBUG ("New challenge, %" G_GSIZE_FORMAT " bytes", challenge_data->len); priv->result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, gabble_server_sasl_channel_challenge_async); challenge_ay = g_array_sized_new (FALSE, FALSE, sizeof (gchar), challenge_data->len); g_array_append_vals (challenge_ay, challenge_data->str, challenge_data->len); tp_svc_channel_interface_sasl_authentication_emit_new_challenge ( self, challenge_ay); }
void gabble_server_sasl_channel_success_async (GabbleServerSaslChannel *self, GAsyncReadyCallback callback, gpointer user_data) { GabbleServerSaslChannelPrivate *priv = self->priv; GSimpleAsyncResult *r; g_assert (!tp_base_channel_is_destroyed ((TpBaseChannel *) self)); g_assert (priv->result == NULL); r = g_simple_async_result_new (G_OBJECT (self), callback, user_data, gabble_server_sasl_channel_success_async); DEBUG (""); if (self->priv->sasl_status != TP_SASL_STATUS_CLIENT_ACCEPTED) { priv->result = r; change_current_state (self, TP_SASL_STATUS_SERVER_SUCCEEDED, NULL, NULL); } else { change_current_state (self, TP_SASL_STATUS_SUCCEEDED, NULL, NULL); g_simple_async_result_complete_in_idle (r); g_object_unref (r); } }
static void fetion_im_channel_close (TpBaseChannel *self) { GObject *object = (GObject *) self; if (!tp_base_channel_is_destroyed (self)) { TpHandle first_sender; /* The manager wants to be able to respawn the channel if it has pending * messages. When respawned, the channel must have the initiator set * to the contact who sent us those messages (if it isn't already), * and the messages must be marked as having been rescued so they * don't get logged twice. */ if (tp_message_mixin_has_pending_messages (object, &first_sender)) { tp_message_mixin_set_rescued (object); tp_base_channel_reopened (self, first_sender); } else { tp_base_channel_destroyed (self); } } }
static void _im_channel_closed_cb (IdleIMChannel *chan, gpointer user_data) { IdleIMManager *self = IDLE_IM_MANAGER (user_data); IdleIMManagerPrivate *priv = IDLE_IM_MANAGER_GET_PRIVATE (self); TpBaseChannel *base = TP_BASE_CHANNEL (chan); tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL (chan)); if (priv->channels) { TpHandle handle = tp_base_channel_get_target_handle (base); if (tp_base_channel_is_destroyed (base)) { IDLE_DEBUG ("removing channel with handle %u", handle); g_hash_table_remove (priv->channels, GUINT_TO_POINTER (handle)); } else { IDLE_DEBUG ("reopening channel with handle %u due to pending messages", handle); tp_channel_manager_emit_new_channel (self, (TpExportableChannel *) chan, NULL); } } }
static void foreach_dispose (gpointer key, gpointer _channel, gpointer user_data) { /* Ensure "closed" has been emitted */ if (!tp_base_channel_is_destroyed (_channel)) { g_object_run_dispose (_channel); } }
static void destroyable_destroy (TpSvcChannelInterfaceDestroyable *iface, DBusGMethodInvocation *context) { TpBaseChannel *self = TP_BASE_CHANNEL (iface); tp_message_mixin_clear ((GObject *) self); fetion_im_channel_close (self); g_assert (tp_base_channel_is_destroyed (self)); tp_svc_channel_interface_destroyable_return_from_destroy (context); }
static void gabble_server_sasl_channel_finalize (GObject *object) { GabbleServerSaslChannel *self = GABBLE_SERVER_SASL_CHANNEL (object); GabbleServerSaslChannelPrivate *priv = self->priv; /* a ref is held for the channel's lifetime */ g_assert (tp_base_channel_is_destroyed ((TpBaseChannel *) self)); g_assert (priv->result == NULL); g_strfreev (priv->available_mechanisms); g_free (priv->sasl_error); g_hash_table_unref (priv->sasl_error_details); if (G_OBJECT_CLASS (gabble_server_sasl_channel_parent_class)->finalize) G_OBJECT_CLASS (gabble_server_sasl_channel_parent_class)->finalize (object); }
/** * 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); } }