diff -r d0f3a028347a -r 59927b2d3b75 telepathygabble/src/muc-factory.c --- a/telepathygabble/src/muc-factory.c Tue Feb 02 01:10:06 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,879 +0,0 @@ -/* - * muc-factory.c - Source for GabbleMucFactory - * Copyright (C) 2006 Collabora Ltd. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - */ - - -#include -#include -#include - -#include - -#include -#include - -#include "loudmouth/loudmouth.h" - -#include "debug.h" -#include "disco.h" -#include "gabble-connection.h" -#include "gabble-presence-cache.h" -#include "gabble-muc-channel.h" -#include "gabble-roomlist-channel.h" -#include "handles.h" -#include "muc-factory.h" -#include "namespaces.h" -#include "telepathy-interfaces.h" -#include "text-mixin.h" -#include "tp-channel-factory-iface.h" -#include "util.h" - -static void gabble_muc_factory_iface_init (gpointer g_iface, gpointer iface_data); - -#ifndef EMULATOR -G_DEFINE_TYPE_WITH_CODE (GabbleMucFactory, gabble_muc_factory, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_FACTORY_IFACE, gabble_muc_factory_iface_init)); -#endif - -#ifdef EMULATOR -#include "libgabble_wsd_solution.h" - - GET_STATIC_VAR_FROM_TLS(gabble_muc_factory_parent_class,muc_factory,gpointer) - #define gabble_muc_factory_parent_class (*GET_WSD_VAR_NAME(gabble_muc_factory_parent_class,muc_factory,s)()) - - GET_STATIC_VAR_FROM_TLS(g_define_type_id,muc_factory,GType) - #define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,muc_factory,s)()) - -static void gabble_muc_factory_init (GabbleMucFactory *self); -static void gabble_muc_factory_class_init (GabbleMucFactoryClass *klass); -static void gabble_muc_factory_class_intern_init (gpointer klass) -{ - gabble_muc_factory_parent_class = g_type_class_peek_parent (klass); - gabble_muc_factory_class_init ((GabbleMucFactoryClass*) klass); - } - EXPORT_C GType gabble_muc_factory_get_type (void) - { - if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleMucFactoryClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_muc_factory_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMucFactory), 0, (GInstanceInitFunc) gabble_muc_factory_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMucFactory"), &g_define_type_info, (GTypeFlags) 0); { { static const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) gabble_muc_factory_iface_init }; g_type_add_interface_static (g_define_type_id, tp_channel_factory_iface_get_type(), &g_implement_interface_info); } ; } } return g_define_type_id; } ; - -#endif -#define DBUS_API_SUBJECT_TO_CHANGE -#define DEBUG_FLAG GABBLE_DEBUG_MUC - -#ifdef DEBUG_FLAG -//#define DEBUG(format, ...) -#define DEBUGGING 0 -#define NODE_DEBUG(n, s) -#endif /* DEBUG_FLAG */ - -/* properties */ -enum -{ - PROP_CONNECTION = 1, - LAST_PROPERTY -}; - -typedef struct _GabbleMucFactoryPrivate GabbleMucFactoryPrivate; -struct _GabbleMucFactoryPrivate -{ - GabbleConnection *conn; - - LmMessageHandler *message_cb; - LmMessageHandler *presence_cb; - - GHashTable *channels; - GabbleRoomlistChannel *roomlist_channel; - - GHashTable *disco_requests; - - gboolean dispose_has_run; -}; - -#define GABBLE_MUC_FACTORY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GABBLE_TYPE_MUC_FACTORY, GabbleMucFactoryPrivate)) - -static GObject *gabble_muc_factory_constructor (GType type, guint n_props, GObjectConstructParam *props); - -static void -gabble_muc_factory_init (GabbleMucFactory *fac) -{ - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal, - NULL, g_object_unref); - - priv->disco_requests = g_hash_table_new_full (g_direct_hash, g_direct_equal, - NULL, NULL); - - priv->message_cb = NULL; - priv->presence_cb = NULL; - - priv->conn = NULL; - priv->dispose_has_run = FALSE; -} - -static GObject * -gabble_muc_factory_constructor (GType type, guint n_props, - GObjectConstructParam *props) -{ - GObject *obj; - /* GabbleMucFactoryPrivate *priv; */ - - obj = G_OBJECT_CLASS (gabble_muc_factory_parent_class)-> - constructor (type, n_props, props); - /* priv = GABBLE_MUC_FACTORY_GET_PRIVATE (obj); */ - - return obj; -} - -static void -cancel_disco_request (gpointer key, gpointer value, gpointer user_data) -{ - GabbleDisco *disco = GABBLE_DISCO (user_data); - GabbleDiscoRequest *request = (GabbleDiscoRequest *) key; - - gabble_disco_cancel_request (disco, request); -} - -static void -gabble_muc_factory_dispose (GObject *object) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (object); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - if (priv->dispose_has_run) - return; - - gabble_debug (DEBUG_FLAG, "dispose called"); - priv->dispose_has_run = TRUE; - - tp_channel_factory_iface_close_all (TP_CHANNEL_FACTORY_IFACE (object)); - - g_hash_table_foreach (priv->disco_requests, cancel_disco_request, priv->conn->disco); - g_hash_table_destroy (priv->disco_requests); - - if (G_OBJECT_CLASS (gabble_muc_factory_parent_class)->dispose) - G_OBJECT_CLASS (gabble_muc_factory_parent_class)->dispose (object); -} - -static void -gabble_muc_factory_get_property (GObject *object, - guint property_id, - GValue *value, - GParamSpec *pspec) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (object); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - switch (property_id) { - case PROP_CONNECTION: - g_value_set_object (value, priv->conn); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); - break; - } -} - -static void -gabble_muc_factory_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (object); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - switch (property_id) { - case PROP_CONNECTION: - priv->conn = g_value_get_object (value); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); - break; - } -} - -static void -gabble_muc_factory_class_init (GabbleMucFactoryClass *gabble_muc_factory_class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (gabble_muc_factory_class); - GParamSpec *param_spec; - - g_type_class_add_private (gabble_muc_factory_class, sizeof (GabbleMucFactoryPrivate)); - - object_class->constructor = gabble_muc_factory_constructor; - object_class->dispose = gabble_muc_factory_dispose; - - object_class->get_property = gabble_muc_factory_get_property; - object_class->set_property = gabble_muc_factory_set_property; - - param_spec = g_param_spec_object ("connection", "GabbleConnection object", - "Gabble connection object that owns this " - "MUC factory object.", - GABBLE_TYPE_CONNECTION, - G_PARAM_CONSTRUCT_ONLY | - G_PARAM_READWRITE | - G_PARAM_STATIC_NICK | - G_PARAM_STATIC_BLURB); - g_object_class_install_property (object_class, PROP_CONNECTION, param_spec); -} - - -static GabbleMucChannel * -get_muc_from_jid (GabbleMucFactory *fac, const gchar *jid) -{ - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - GabbleHandle handle; - GabbleMucChannel *chan = NULL; - - if (gabble_handle_for_room_exists (priv->conn->handles, jid, TRUE)) - { - handle = gabble_handle_for_room (priv->conn->handles, jid); - - chan = g_hash_table_lookup (priv->channels, GUINT_TO_POINTER (handle)); - } - - return chan; -} - - -/** - * muc_channel_closed_cb: - * - * Signal callback for when a MUC channel is closed. Removes the references - * that MucFactory holds to them. - */ -static void -muc_channel_closed_cb (GabbleMucChannel *chan, gpointer user_data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (user_data); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - GabbleHandle room_handle; - - if (priv->channels != NULL) - { - g_object_get (chan, "handle", &room_handle, NULL); - - gabble_debug (DEBUG_FLAG, "removing MUC channel with handle %d", room_handle); - - g_hash_table_remove (priv->channels, GINT_TO_POINTER (room_handle)); - } -} - -static void -muc_ready_cb (GabbleMucChannel *chan, - gpointer data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (data); - - gabble_debug (DEBUG_FLAG, "chan=%p", chan); - - g_signal_emit_by_name (fac, "new-channel", chan); -} - -static void -muc_join_error_cb (GabbleMucChannel *chan, - GError *error, - gpointer data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (data); - - gabble_debug (DEBUG_FLAG, "error->code=%u, error->message=\"%s\"", error->code, error->message); - - g_signal_emit_by_name (fac, "channel-error", chan, error); -} - -/** - * new_muc_channel - */ -static GabbleMucChannel * -new_muc_channel (GabbleMucFactory *fac, GabbleHandle handle, gboolean invite_self) -{ - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - GabbleMucChannel *chan; - char *object_path; - - g_assert (g_hash_table_lookup (priv->channels, GINT_TO_POINTER (handle)) == NULL); - - object_path = g_strdup_printf ("%s/MucChannel%u", priv->conn->object_path, handle); - - gabble_debug (DEBUG_FLAG, "creating new chan, object path %s", object_path); - - chan = g_object_new (GABBLE_TYPE_MUC_CHANNEL, - "connection", priv->conn, - "object-path", object_path, - "handle", handle, - "invite-self", invite_self, - NULL); - - g_signal_connect (chan, "closed", (GCallback) muc_channel_closed_cb, fac); - - g_hash_table_insert (priv->channels, GINT_TO_POINTER (handle), chan); - - g_free (object_path); - - g_signal_connect (chan, "ready", G_CALLBACK (muc_ready_cb), fac); - g_signal_connect (chan, "join-error", G_CALLBACK (muc_join_error_cb), - fac); - - return chan; -} - - -struct DiscoInviteData { - GabbleMucFactory *factory; - gchar *reason; - GabbleHandle inviter; -}; - -/** - * obsolete_invite_disco_cb: - * - * Callback for disco request we fired upon encountering obsolete disco. - * If the object is in fact MUC room, create a channel for it. - */ -static void -obsolete_invite_disco_cb (GabbleDisco *self, - GabbleDiscoRequest *request, - const gchar *jid, - const gchar *node, - LmMessageNode *query_result, - GError* error, - gpointer user_data) -{ - struct DiscoInviteData *data = (struct DiscoInviteData *) user_data; - - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (data->factory); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - LmMessageNode *identity; - const char *category, *type; - GabbleHandle handle; - - g_hash_table_remove (priv->disco_requests, request); - - identity = lm_message_node_get_child (query_result, "identity"); - if (NULL == identity) - return; - - category = lm_message_node_get_attribute (identity, "category"); - if (NULL == category) - return; - - type = lm_message_node_get_attribute (identity, "type"); - if (NULL == type) - return; - - if (0 != strcmp (category, "conference") || - 0 != strcmp (type, "text")) - { - gabble_debug (DEBUG_FLAG, "obsolete invite request specified invalid jid '%s', ignoring", jid); - } - - /* OK, it's MUC after all, create a new channel */ - handle = gabble_handle_for_room (priv->conn->handles, jid); - - if (g_hash_table_lookup (priv->channels, GINT_TO_POINTER (handle)) == NULL) - { - GabbleMucChannel *chan; - chan = new_muc_channel (fac, handle, FALSE); - _gabble_muc_channel_handle_invited (chan, data->inviter, data->reason); - } - else - { - gabble_debug (DEBUG_FLAG, "ignoring invite to a room '%s' we're already in", jid); - } - - g_free (data->reason); - g_free (data); -} - - -/** - * muc_factory_message_cb: - * - * Called by loudmouth when we get an incoming . - * We filter only groupchat and MUC messages, ignoring the rest. - */ -static LmHandlerResult -muc_factory_message_cb (LmMessageHandler *handler, - LmConnection *connection, - LmMessage *message, - gpointer user_data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (user_data); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - const gchar *from, *body, *body_offset; - time_t stamp; - TpChannelTextMessageType msgtype; - LmMessageNode *node; - TpHandleType handle_type; - GabbleHandle room_handle, handle; - GabbleMucChannel *chan; - GabbleTextMixinSendError send_error; - - if (!gabble_text_mixin_parse_incoming_message (message, &from, &stamp, - &msgtype, &body, &body_offset, &send_error)) - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - - /* does it have a muc subnode? */ - node = lm_message_node_get_child_with_namespace (message->node, "x", - NS_MUC_USER); - if (node != NULL) - { - /* and an invitation? */ - node = lm_message_node_get_child (node, "invite"); - if (node != NULL) - { - LmMessageNode *reason_node; - const gchar *invite_from, *reason; - GabbleHandle inviter_handle; - - if (send_error != CHANNEL_TEXT_SEND_NO_ERROR) - { - NODE_DEBUG (message->node, "got a MUC invitation message " - "with a send error; ignoring"); - - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - } - - invite_from = lm_message_node_get_attribute (node, "from"); - if (invite_from == NULL) - { - NODE_DEBUG (message->node, "got a MUC invitation message " - "without a from field on the invite node, " - "ignoring"); - - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - } - - inviter_handle = gabble_handle_for_contact (priv->conn->handles, - invite_from, FALSE); - - reason_node = lm_message_node_get_child (node, "reason"); - if (reason_node != NULL) - { - reason = lm_message_node_get_value (reason_node); - } - else - { - reason = ""; - NODE_DEBUG (message->node, "no MUC invite reason specified"); - } - - /* create the channel */ - handle = gabble_handle_for_room (priv->conn->handles, from); - - if (g_hash_table_lookup (priv->channels, GINT_TO_POINTER (handle)) == NULL) - { - chan = new_muc_channel (fac, handle, FALSE); - _gabble_muc_channel_handle_invited (chan, inviter_handle, reason); - } - else - { - NODE_DEBUG (message->node, "ignoring invite to a room we're already in"); - } - - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - } - else - { - GabbleHandle inviter_handle; - GabbleDiscoRequest *request; - const gchar *reason; - struct DiscoInviteData *disco_udata; - - /* check for obsolete invite method */ - for (node = message->node->children; node != NULL; node = node->next) - if (strcmp (node->name, "x") == 0) - if (lm_message_node_has_namespace (node, NS_X_CONFERENCE, NULL)) - break; - - if (node == NULL) - goto HANDLE_MESSAGE; - - /* the room JID is in x */ - from = lm_message_node_get_attribute (node, "jid"); - if (from == NULL) - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - - /* the inviter JID is in "from" */ - inviter_handle = gabble_handle_for_contact (priv->conn->handles, - from, FALSE); - - /* reason is the body */ - reason = body; - - disco_udata = g_new0 (struct DiscoInviteData, 1); - disco_udata->factory = fac; - disco_udata->reason = g_strdup (reason); - disco_udata->inviter = inviter_handle; - - NODE_DEBUG (message->node, "received obsolete invite method"); - - request = gabble_disco_request (priv->conn->disco, GABBLE_DISCO_TYPE_INFO, - from, NULL, obsolete_invite_disco_cb, disco_udata, G_OBJECT (fac), NULL); - - if (request != NULL) - g_hash_table_insert (priv->disco_requests, request, NULL); - - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - -HANDLE_MESSAGE: - - /* check if a room with the jid exists */ - if (!gabble_handle_for_room_exists (priv->conn->handles, from, TRUE)) - { - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - } - - room_handle = gabble_handle_for_room (priv->conn->handles, from); - - /* find the MUC channel */ - chan = g_hash_table_lookup (priv->channels, GUINT_TO_POINTER (room_handle)); - - if (chan == NULL) - { - g_warning ("%s: ignoring groupchat message from known handle with " - "no MUC channel", G_STRFUNC); - - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - } - - /* get the handle of the sender, which is either the room - * itself or one of its members */ - if (gabble_handle_for_room_exists (priv->conn->handles, from, FALSE)) - { - handle_type = TP_HANDLE_TYPE_ROOM; - handle = room_handle; - } - else - { - handle_type = TP_HANDLE_TYPE_CONTACT; - handle = gabble_handle_for_contact (priv->conn->handles, from, TRUE); - } - - if (send_error != CHANNEL_TEXT_SEND_NO_ERROR) - { - _gabble_text_mixin_send_error_signal (G_OBJECT (chan), send_error, stamp, - msgtype, body_offset); - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - - if (_gabble_muc_channel_receive (chan, msgtype, handle_type, handle, stamp, - body_offset, message)) - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; -} - - -/** - * connection_presence_muc_cb: - * @handler: #LmMessageHandler for this message - * @connection: #LmConnection that originated the message - * @message: the presence message - * @user_data: callback data - * - * Called by loudmouth when we get an incoming . - */ -static LmHandlerResult -muc_factory_presence_cb (LmMessageHandler *handler, - LmConnection *lmconn, - LmMessage *msg, - gpointer user_data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (user_data); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - const char *from; - LmMessageSubType sub_type; - GabbleMucChannel *muc_chan; - LmMessageNode *x_node; - - g_assert (lmconn == priv->conn->lmconn); - - from = lm_message_node_get_attribute (msg->node, "from"); - - if (from == NULL) - { - NODE_DEBUG (msg->node, "presence stanza without from attribute, ignoring"); - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - } - - sub_type = lm_message_get_sub_type (msg); - - muc_chan = get_muc_from_jid (fac, from); - - /* is it an error and for a MUC? */ - if (sub_type == LM_MESSAGE_SUB_TYPE_ERROR - && muc_chan != NULL) - { - _gabble_muc_channel_presence_error (muc_chan, from, msg->node); - - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - - x_node = lm_message_node_get_child_with_namespace (msg->node, "x", NS_MUC_USER); - - /* is it a MUC member presence? */ - if (x_node != NULL) - { - if (muc_chan != NULL) - { - GabbleHandle handle; - - handle = gabble_handle_for_contact (priv->conn->handles, from, TRUE); - if (handle == 0) - { - NODE_DEBUG (msg->node, "discarding MUC presence from malformed jid"); - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - - _gabble_muc_channel_member_presence_updated (muc_chan, handle, - msg, x_node); - } - else - { - NODE_DEBUG (msg->node, "discarding unexpected MUC member presence"); - - return LM_HANDLER_RESULT_REMOVE_MESSAGE; - } - } - - return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - -} - -static void -roomlist_channel_closed_cb (GabbleRoomlistChannel *chan, gpointer data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (data); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - if (priv->roomlist_channel != NULL) - { - g_object_unref (priv->roomlist_channel); - priv->roomlist_channel = NULL; - } -} - -static gboolean -make_roomlist_channel (GabbleMucFactory *fac) -{ - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - if (priv->roomlist_channel == NULL) - { - const gchar *server; - gchar *object_path; - - server = _gabble_connection_find_conference_server (priv->conn); - - if (server == NULL) - return FALSE; - - object_path = g_strdup_printf ("%s/RoomlistChannel", priv->conn->object_path); - - priv->roomlist_channel = _gabble_roomlist_channel_new (priv->conn, - object_path, server); - - g_signal_connect (priv->roomlist_channel, "closed", - (GCallback) roomlist_channel_closed_cb, fac); - - g_signal_emit_by_name (fac, "new-channel", priv->roomlist_channel); - - g_free (object_path); - } - - return TRUE; -} - - - -static void -gabble_muc_factory_iface_close_all (TpChannelFactoryIface *iface) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (iface); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - gabble_debug (DEBUG_FLAG, "closing channels"); - - if (priv->channels != NULL) - { - GHashTable *tmp = priv->channels; - priv->channels = NULL; - g_hash_table_destroy (tmp); - } - - if (priv->roomlist_channel != NULL) - { - GObject *tmp = G_OBJECT (priv->roomlist_channel); - priv->roomlist_channel = NULL; - g_object_unref (tmp); - } -} - -static void -gabble_muc_factory_iface_connecting (TpChannelFactoryIface *iface) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (iface); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - gabble_debug (DEBUG_FLAG, "adding callbacks"); - - g_assert (priv->message_cb == NULL); - g_assert (priv->presence_cb == NULL); - - priv->message_cb = lm_message_handler_new (muc_factory_message_cb, fac, NULL); - lm_connection_register_message_handler (priv->conn->lmconn, priv->message_cb, - LM_MESSAGE_TYPE_MESSAGE, - LM_HANDLER_PRIORITY_NORMAL); - - priv->presence_cb = lm_message_handler_new (muc_factory_presence_cb, fac, NULL); - lm_connection_register_message_handler (priv->conn->lmconn, priv->presence_cb, - LM_MESSAGE_TYPE_PRESENCE, - LM_HANDLER_PRIORITY_NORMAL); -} - - -static void -gabble_muc_factory_iface_connected (TpChannelFactoryIface *iface) -{ - /* nothing to do */ -} - -static void -gabble_muc_factory_iface_disconnected (TpChannelFactoryIface *iface) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (iface); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - - gabble_debug (DEBUG_FLAG, "removing callbacks"); - - g_assert (priv->message_cb != NULL); - g_assert (priv->presence_cb != NULL); - - lm_connection_unregister_message_handler (priv->conn->lmconn, priv->message_cb, - LM_MESSAGE_TYPE_MESSAGE); - lm_message_handler_unref (priv->message_cb); - priv->message_cb = NULL; - - lm_connection_unregister_message_handler (priv->conn->lmconn, priv->presence_cb, - LM_MESSAGE_TYPE_PRESENCE); - lm_message_handler_unref (priv->presence_cb); - priv->presence_cb = NULL; -} - -struct _ForeachData -{ - TpChannelFunc foreach; - gpointer user_data; -}; - -static void -_foreach_slave (gpointer key, gpointer value, gpointer user_data) -{ - struct _ForeachData *data = (struct _ForeachData *) user_data; - TpChannelIface *chan = TP_CHANNEL_IFACE (value); - - data->foreach (chan, data->user_data); -} - -static void -gabble_muc_factory_iface_foreach (TpChannelFactoryIface *iface, TpChannelFunc foreach, gpointer user_data) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (iface); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - struct _ForeachData data; - - data.user_data = user_data; - data.foreach = foreach; - - g_hash_table_foreach (priv->channels, _foreach_slave, &data); - - if (priv->roomlist_channel != NULL) - foreach (TP_CHANNEL_IFACE (priv->roomlist_channel), user_data); -} - -static TpChannelFactoryRequestStatus -gabble_muc_factory_iface_request (TpChannelFactoryIface *iface, - const gchar *chan_type, - TpHandleType handle_type, - guint handle, - TpChannelIface **ret, - GError **error) -{ - GabbleMucFactory *fac = GABBLE_MUC_FACTORY (iface); - GabbleMucFactoryPrivate *priv = GABBLE_MUC_FACTORY_GET_PRIVATE (fac); - GabbleMucChannel *chan; - - if (!g_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_ROOM_LIST)) - { - /* FIXME - delay if services aren't discovered yet? */ - if (!make_roomlist_channel (fac)) - { - gabble_debug (DEBUG_FLAG, "no conference server available for roomlist request"); - return TP_CHANNEL_FACTORY_REQUEST_STATUS_NOT_AVAILABLE; - } - *ret = TP_CHANNEL_IFACE (priv->roomlist_channel); - return TP_CHANNEL_FACTORY_REQUEST_STATUS_DONE; - } - - if (strcmp (chan_type, TP_IFACE_CHANNEL_TYPE_TEXT)) - return TP_CHANNEL_FACTORY_REQUEST_STATUS_NOT_IMPLEMENTED; - - if (handle_type != TP_HANDLE_TYPE_ROOM) - return TP_CHANNEL_FACTORY_REQUEST_STATUS_NOT_AVAILABLE; - - if (!gabble_handle_is_valid (priv->conn->handles, TP_HANDLE_TYPE_ROOM, handle, NULL)) - return TP_CHANNEL_FACTORY_REQUEST_STATUS_INVALID_HANDLE; - - chan = g_hash_table_lookup (priv->channels, GINT_TO_POINTER (handle)); - if (!chan) - { - chan = new_muc_channel (fac, handle, TRUE); - return TP_CHANNEL_FACTORY_REQUEST_STATUS_QUEUED; - } - - if (_gabble_muc_channel_is_ready (chan)) - { - *ret = TP_CHANNEL_IFACE (chan); - return TP_CHANNEL_FACTORY_REQUEST_STATUS_DONE; - } - else - { - return TP_CHANNEL_FACTORY_REQUEST_STATUS_QUEUED; - } -} - -static void -gabble_muc_factory_iface_init (gpointer g_iface, - gpointer iface_data) -{ - TpChannelFactoryIfaceClass *klass = (TpChannelFactoryIfaceClass *) g_iface; - - klass->close_all = gabble_muc_factory_iface_close_all; - klass->connecting = gabble_muc_factory_iface_connecting; - klass->connected = gabble_muc_factory_iface_connected; - klass->disconnected = gabble_muc_factory_iface_disconnected; - klass->foreach = gabble_muc_factory_iface_foreach; - klass->request = gabble_muc_factory_iface_request; -} - -