1 /*

     2  * gabble-muc-channel.c - Source for GabbleMucChannel

     3  * Copyright (C) 2006 Collabora Ltd.

     4  * 

     5  *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>

     6  *

     7  * This library is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Lesser General Public

     9  * License as published by the Free Software Foundation; either

    10  * version 2.1 of the License, or (at your option) any later version.

    11  *

    12  * This library is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Lesser General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Lesser General Public

    18  * License along with this library; if not, write to the Free Software

    19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    20  */

    21 

    22 #include <dbus/dbus-glib.h>

    23 #include <stdio.h>

    24 #include <stdlib.h>

    25 #include <string.h>

    26 #include <time.h>

    27 

    28 

    29 #include "ansi.h"

    30 #include "debug.h"

    31 #include "disco.h"

    32 #include "gabble-connection.h"

    33 #include "gabble-error.h"

    34 #include "namespaces.h"

    35 #include "util.h"

    36 

    37 #include "telepathy-errors.h"

    38 #include "telepathy-helpers.h"

    39 #include "telepathy-interfaces.h"

    40 #include "tp-channel-iface.h"

    41 

    42 #include "gabble-muc-channel.h"

    43 #include "gabble-muc-channel-signals-marshal.h"

    44 

    45 #include "gabble-muc-channel-glue.h"

    46 

    47 #include "gabble_enums.h"

    48 

    49 #define DEBUG_FLAG GABBLE_DEBUG_MUC

    50 #define DEFAULT_JOIN_TIMEOUT (180 * 1000)

    51 #define MAX_NICK_RETRIES 3

    52 

    53 #define PROPS_POLL_INTERVAL_LOW  (60 * 1000 * 5)

    54 #define PROPS_POLL_INTERVAL_HIGH (60 * 1000)

    55 

    56 #ifdef DEBUG_FLAG

    57 //#define DEBUG(format, ...)

    58 #define DEBUGGING 0

    59 #define NODE_DEBUG(n, s)

    60 #endif /* DEBUG_FLAG */

    61 

    62 #ifndef EMULATOR

    63 G_DEFINE_TYPE_WITH_CODE (GabbleMucChannel, gabble_muc_channel,

    64     G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));

    65 #endif

    66 /* signal enum */

    67 enum

    68 {

    69     READY,

    70     JOIN_ERROR,

    71     CLOSED,

    72     PASSWORD_FLAGS_CHANGED,

    73     LAST_SIGNAL 

    74 #ifdef EMULATOR    

    75     = LAST_SIGNAL_MUC

    76 #endif

    77     

    78 };

    79 

    80 

    81 #ifdef EMULATOR

    82 #include "libgabble_wsd_solution.h"

    83 

    84 	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_muc,guint)

    85 	#define signals (GET_WSD_VAR_NAME(signals,gabble_muc, s)())	

    86     

    87     

    88     GET_STATIC_VAR_FROM_TLS(gabble_muc_channel_parent_class,gabble_muc,gpointer)

    89 	#define gabble_muc_channel_parent_class (*GET_WSD_VAR_NAME(gabble_muc_channel_parent_class,gabble_muc,s)())

    90 	

    91 	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_muc,GType)

    92 	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_muc,s)())

    93 	

    94 	

    95 	/*gchar** _s_gabble_muc_muc_roles() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_muc_muc_roles)); }

    96 

    97 	#define muc_roles (GET_WSD_VAR_NAME(muc_roles,gabble_muc, s)())	

    98 	

    99 	

   100 	gchar** _s_gabble_muc_muc_affiliations() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_muc_muc_affiliations)); }

   101 

   102 	#define muc_affiliations (GET_WSD_VAR_NAME(muc_affiliations,gabble_muc, s)())*/	

   103 

   104 

   105 static void gabble_muc_channel_init (GabbleMucChannel *self); 

   106 static void gabble_muc_channel_class_init (GabbleMucChannelClass *klass); 

   107 static void gabble_muc_channel_class_intern_init (gpointer klass) 

   108 {

   109  gabble_muc_channel_parent_class = g_type_class_peek_parent (klass);

   110   gabble_muc_channel_class_init ((GabbleMucChannelClass*) klass);

   111 } 

   112 EXPORT_C GType gabble_muc_channel_get_type (void)

   113  { 

   114  if ((g_define_type_id == 0)) 

   115  { 

   116  static const GTypeInfo g_define_type_info = { sizeof (GabbleMucChannelClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_muc_channel_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMucChannel), 0, (GInstanceInitFunc) gabble_muc_channel_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMucChannel"), &g_define_type_info, (GTypeFlags) 0); { { static const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) ((void *)0) }; g_type_add_interface_static (g_define_type_id, tp_channel_iface_get_type(), &g_implement_interface_info); } ; } } return g_define_type_id; 

   117  };

   118 		

   119 #else

   120 

   121 	static guint signals[LAST_SIGNAL] = {0};

   122 

   123 #endif

   124 

   125 /* properties */

   126 enum

   127 {

   128   PROP_OBJECT_PATH = 1,

   129   PROP_CHANNEL_TYPE,

   130   PROP_HANDLE_TYPE,

   131   PROP_HANDLE,

   132   PROP_CONNECTION,

   133   PROP_STATE,

   134   PROP_INVITE_SELF,

   135   LAST_PROPERTY

   136 };

   137 

   138 typedef enum {

   139     MUC_STATE_CREATED = 0,

   140     MUC_STATE_INITIATED,

   141     MUC_STATE_AUTH,

   142     MUC_STATE_JOINED,

   143     MUC_STATE_ENDED,

   144 } GabbleMucState;

   145 

   146 #define ENABLE_DEBUG

   147 #ifdef ENABLE_DEBUG

   148 static const gchar *muc_states[] =

   149 {

   150   "MUC_STATE_CREATED",

   151   "MUC_STATE_INITIATED",

   152   "MUC_STATE_AUTH",

   153   "MUC_STATE_JOINED",

   154   "MUC_STATE_ENDED",

   155 };

   156 #endif

   157 

   158 /* role and affiliation enums */

   159 typedef enum {

   160     ROLE_NONE = 0,

   161     ROLE_VISITOR,

   162     ROLE_PARTICIPANT,

   163     ROLE_MODERATOR,

   164 

   165     NUM_ROLES,

   166 

   167     INVALID_ROLE,

   168 } GabbleMucRole;

   169 

   170 typedef enum {

   171     AFFILIATION_NONE = 0,

   172     AFFILIATION_MEMBER,

   173     AFFILIATION_ADMIN,

   174     AFFILIATION_OWNER,

   175 

   176     NUM_AFFILIATIONS,

   177 

   178     INVALID_AFFILIATION,

   179 } GabbleMucAffiliation;

   180 

   181 //#ifndef EMULATOR

   182 

   183 static const gchar *muc_roles[NUM_ROLES] =

   184 {

   185   "none",

   186   "visitor",

   187   "participant",

   188   "moderator",

   189 };

   190 

   191 static const gchar *muc_affiliations[NUM_AFFILIATIONS] =

   192 {

   193   "none",

   194   "member",

   195   "admin",

   196   "owner",

   197 };

   198 

   199 //#endif

   200 

   201 /* room properties */

   202 enum

   203 {

   204   ROOM_PROP_ANONYMOUS = 0,

   205   ROOM_PROP_INVITE_ONLY,

   206   ROOM_PROP_MODERATED,

   207   ROOM_PROP_NAME,

   208   ROOM_PROP_DESCRIPTION,

   209   ROOM_PROP_PASSWORD,

   210   ROOM_PROP_PASSWORD_REQUIRED,

   211   ROOM_PROP_PERSISTENT,

   212   ROOM_PROP_PRIVATE,

   213   ROOM_PROP_SUBJECT,

   214   ROOM_PROP_SUBJECT_CONTACT,

   215   ROOM_PROP_SUBJECT_TIMESTAMP,

   216 

   217   NUM_ROOM_PROPS,

   218 

   219   INVALID_ROOM_PROP,

   220 };

   221 

   222 const GabblePropertySignature room_property_signatures[NUM_ROOM_PROPS] = {

   223       { "anonymous",         G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   224       { "invite-only",       G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   225       { "moderated",         G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   226       { "name",              G_TYPE_STRING },   /* impl: READ, WRITE */

   227       { "description",       G_TYPE_STRING },   /* impl: READ, WRITE */

   228       { "password",          G_TYPE_STRING },   /* impl: WRITE */

   229       { "password-required", G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   230       { "persistent",        G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   231       { "private",           G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

   232       { "subject",           G_TYPE_STRING },   /* impl: READ, WRITE */

   233       { "subject-contact",   G_TYPE_UINT },     /* impl: READ */

   234       { "subject-timestamp", G_TYPE_UINT },     /* impl: READ */

   235 };

   236 

   237 /* private structures */

   238 

   239 typedef struct _GabbleMucChannelPrivate GabbleMucChannelPrivate;

   240 

   241 struct _GabbleMucChannelPrivate

   242 {

   243   GabbleConnection *conn;

   244   gchar *object_path;

   245 

   246   GabbleMucState state;

   247 

   248   guint join_timer_id;

   249   guint poll_timer_id;

   250 

   251   TpChannelPasswordFlags password_flags;

   252   DBusGMethodInvocation *password_ctx;

   253   gchar *password;

   254 

   255   GabbleHandle handle;

   256   const gchar *jid;

   257 

   258   guint nick_retry_count;

   259   GString *self_jid;

   260   GabbleMucRole self_role;

   261   GabbleMucAffiliation self_affil;

   262 

   263   guint recv_id;

   264 

   265   GabblePropertiesContext *properties_ctx;

   266 

   267   gboolean ready_emitted;

   268 

   269   gboolean closed;

   270   gboolean dispose_has_run;

   271 

   272   gboolean invite_self;

   273 };

   274 

   275 #define GABBLE_MUC_CHANNEL_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), GABBLE_TYPE_MUC_CHANNEL, GabbleMucChannelPrivate))

   276 

   277 static void

   278 gabble_muc_channel_init (GabbleMucChannel *obj)

   279 {

   280   /* do nothing? */

   281 }

   282 

   283 static void contact_handle_to_room_identity (GabbleMucChannel *, GabbleHandle, GabbleHandle *, GString **);

   284 

   285 static GObject *

   286 gabble_muc_channel_constructor (GType type, guint n_props,

   287                                 GObjectConstructParam *props)

   288 {

   289   GObject *obj;

   290   GabbleMucChannelPrivate *priv;

   291   DBusGConnection *bus;

   292   GabbleHandleRepo *handles;

   293   GabbleHandle self_handle;

   294   gboolean valid;

   295 

   296   obj = G_OBJECT_CLASS (gabble_muc_channel_parent_class)->

   297            constructor (type, n_props, props);

   298 

   299   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (obj);

   300 

   301   handles = priv->conn->handles;

   302 

   303   /* ref our room handle */

   304   valid = gabble_handle_ref (handles, TP_HANDLE_TYPE_ROOM, priv->handle);

   305   g_assert (valid);

   306 

   307   /* get the room's jid */

   308   priv->jid = gabble_handle_inspect (handles, TP_HANDLE_TYPE_ROOM, priv->handle);

   309 

   310   /* get our own identity in the room */

   311   contact_handle_to_room_identity (GABBLE_MUC_CHANNEL (obj), priv->conn->self_handle,

   312                                    &self_handle, &priv->self_jid);

   313 

   314   valid = gabble_handle_ref (handles, TP_HANDLE_TYPE_CONTACT, self_handle);

   315   g_assert (valid);

   316 

   317   /* initialize our own role and affiliation */

   318   priv->self_role = ROLE_NONE;

   319   priv->self_affil = AFFILIATION_NONE;

   320 

   321   /* register object on the bus */

   322   bus = tp_get_bus ();

   323   dbus_g_connection_register_g_object (bus, priv->object_path, obj);

   324 

   325   /* initialize group mixin */

   326   gabble_group_mixin_init (obj, G_STRUCT_OFFSET (GabbleMucChannel, group),

   327                            handles, self_handle);

   328 

   329   /* set initial group flags */

   330   gabble_group_mixin_change_flags (obj,

   331       TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES |

   332       TP_CHANNEL_GROUP_FLAG_CAN_ADD,

   333       0);

   334 

   335   /* initialize properties mixin */

   336   gabble_properties_mixin_init (obj, G_STRUCT_OFFSET (

   337         GabbleMucChannel, properties));

   338 

   339   /* initialize text mixin */

   340   gabble_text_mixin_init (obj, G_STRUCT_OFFSET (GabbleMucChannel, text), handles, FALSE);

   341 

   342   gabble_text_mixin_set_message_types (obj,

   343       TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL,

   344       TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION,

   345       G_MAXUINT);

   346 

   347   /* add ourselves to group mixin if needed */

   348   if (priv->invite_self)

   349     {

   350       GError *error = NULL;

   351       GArray *members = g_array_sized_new (FALSE, FALSE, sizeof (GabbleHandle), 1);

   352       g_array_append_val (members, self_handle);

   353       gabble_group_mixin_add_members (obj, members, "", &error);

   354       g_assert (error == NULL);

   355       g_array_free (members, TRUE);

   356     }

   357   return obj;

   358 }

   359 

   360 static void

   361 properties_disco_cb (GabbleDisco *disco,

   362                      GabbleDiscoRequest *request,

   363                      const gchar *jid,

   364                      const gchar *node,

   365                      LmMessageNode *query_result,

   366                      GError *error,

   367                      gpointer user_data)

   368 {

   369   GabbleMucChannel *chan = user_data;

   370   GabbleMucChannelPrivate *priv;

   371   GArray *changed_props_val, *changed_props_flags;

   372   LmMessageNode *lm_node;

   373   const gchar *str;

   374   GValue val = { 0, };

   375 

   376   g_assert (GABBLE_IS_MUC_CHANNEL (chan));

   377 

   378   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   379 

   380   if (error)

   381     {

   382       gabble_debug (DEBUG_FLAG, "got error %s", error->message);

   383       return;

   384     }

   385 

   386   NODE_DEBUG (query_result, "disco query result");

   387 

   388   changed_props_val = changed_props_flags = NULL;

   389 

   390 

   391   /*

   392    * Update room definition.

   393    */

   394 

   395   /* ROOM_PROP_NAME */

   396   lm_node = lm_message_node_get_child (query_result, "identity");

   397   if (lm_node)

   398     {

   399       const gchar *type, *category, *name;

   400 

   401       type = lm_message_node_get_attribute (lm_node, "type");

   402       category = lm_message_node_get_attribute (lm_node, "category");

   403       name = lm_message_node_get_attribute (lm_node, "name");

   404 

   405       if (NULL != type && 0 == strcmp (type, "text") &&

   406           NULL != category && 0 == strcmp (category, "conference") &&

   407           NULL != name)

   408         {

   409           g_value_init (&val, G_TYPE_STRING);

   410           g_value_set_string (&val, name);

   411 

   412           gabble_properties_mixin_change_value (G_OBJECT (chan), ROOM_PROP_NAME,

   413                                                 &val, &changed_props_val);

   414 

   415           gabble_properties_mixin_change_flags (G_OBJECT (chan), ROOM_PROP_NAME,

   416                                                 TP_PROPERTY_FLAG_READ,

   417                                                 0, &changed_props_flags);

   418 

   419           g_value_unset (&val);

   420         }

   421     }

   422 

   423   for (lm_node = query_result->children; lm_node; lm_node = lm_node->next)

   424     {

   425       guint prop_id = INVALID_ROOM_PROP;

   426 

   427       if (strcmp (lm_node->name, "feature") == 0)

   428         {

   429           str = lm_message_node_get_attribute (lm_node, "var");

   430           if (str == NULL)

   431             continue;

   432 

   433           /* ROOM_PROP_ANONYMOUS */

   434           if (strcmp (str, "muc_nonanonymous") == 0)

   435             {

   436               prop_id = ROOM_PROP_ANONYMOUS;

   437               g_value_init (&val, G_TYPE_BOOLEAN);

   438               g_value_set_boolean (&val, FALSE);

   439             }

   440           else if (strcmp (str, "muc_semianonymous") == 0 ||

   441                    strcmp (str, "muc_anonymous") == 0)

   442             {

   443               prop_id = ROOM_PROP_ANONYMOUS;

   444               g_value_init (&val, G_TYPE_BOOLEAN);

   445               g_value_set_boolean (&val, TRUE);

   446             }

   447 

   448           /* ROOM_PROP_INVITE_ONLY */

   449           else if (strcmp (str, "muc_open") == 0)

   450             {

   451               prop_id = ROOM_PROP_INVITE_ONLY;

   452               g_value_init (&val, G_TYPE_BOOLEAN);

   453               g_value_set_boolean (&val, FALSE);

   454             }

   455           else if (strcmp (str, "muc_membersonly") == 0)

   456             {

   457               prop_id = ROOM_PROP_INVITE_ONLY;

   458               g_value_init (&val, G_TYPE_BOOLEAN);

   459               g_value_set_boolean (&val, TRUE);

   460             }

   461 

   462           /* ROOM_PROP_MODERATED */

   463           else if (strcmp (str, "muc_unmoderated") == 0)

   464             {

   465               prop_id = ROOM_PROP_MODERATED;

   466               g_value_init (&val, G_TYPE_BOOLEAN);

   467               g_value_set_boolean (&val, FALSE);

   468             }

   469           else if (strcmp (str, "muc_moderated") == 0)

   470             {

   471               prop_id = ROOM_PROP_MODERATED;

   472               g_value_init (&val, G_TYPE_BOOLEAN);

   473               g_value_set_boolean (&val, TRUE);

   474             }

   475 

   476           /* ROOM_PROP_PASSWORD_REQUIRED */

   477           else if (strcmp (str, "muc_unsecure") == 0 ||

   478                    strcmp (str, "muc_unsecured") == 0)

   479             {

   480               prop_id = ROOM_PROP_PASSWORD_REQUIRED;

   481               g_value_init (&val, G_TYPE_BOOLEAN);

   482               g_value_set_boolean (&val, FALSE);

   483             }

   484           else if (strcmp (str, "muc_passwordprotected") == 0)

   485             {

   486               prop_id = ROOM_PROP_PASSWORD_REQUIRED;

   487               g_value_init (&val, G_TYPE_BOOLEAN);

   488               g_value_set_boolean (&val, TRUE);

   489             }

   490 

   491           /* ROOM_PROP_PERSISTENT */

   492           else if (strcmp (str, "muc_temporary") == 0)

   493             {

   494               prop_id = ROOM_PROP_PERSISTENT;

   495               g_value_init (&val, G_TYPE_BOOLEAN);

   496               g_value_set_boolean (&val, FALSE);

   497             }

   498           else if (strcmp (str, "muc_persistent") == 0)

   499             {

   500               prop_id = ROOM_PROP_PERSISTENT;

   501               g_value_init (&val, G_TYPE_BOOLEAN);

   502               g_value_set_boolean (&val, TRUE);

   503             }

   504 

   505           /* ROOM_PROP_PRIVATE */

   506           else if (strcmp (str, "muc_public") == 0)

   507             {

   508               prop_id = ROOM_PROP_PRIVATE;

   509               g_value_init (&val, G_TYPE_BOOLEAN);

   510               g_value_set_boolean (&val, FALSE);

   511             }

   512           else if (strcmp (str, "muc_hidden") == 0)

   513             {

   514               prop_id = ROOM_PROP_PRIVATE;

   515               g_value_init (&val, G_TYPE_BOOLEAN);

   516               g_value_set_boolean (&val, TRUE);

   517             }

   518 

   519           /* Ignored */

   520           else if (strcmp (str, NS_MUC) == 0)

   521             {

   522             }

   523 

   524           /* Unhandled */

   525           else

   526             {

   527               g_warning ("%s: unhandled feature '%s'", G_STRFUNC, str);

   528             }

   529         }

   530       else if (strcmp (lm_node->name, "x") == 0)

   531         {

   532           if (lm_message_node_has_namespace (lm_node, NS_X_DATA, NULL))

   533             {

   534               LmMessageNode *field, *value_node;

   535 

   536               for (field = lm_node->children; field; field = field->next)

   537                 {

   538                   if (strcmp (field->name, "field") != 0)

   539                     continue;

   540 

   541                   str = lm_message_node_get_attribute (field, "var");

   542                   if (str == NULL)

   543                     continue;

   544 

   545                   if (strcmp (str, "muc#roominfo_description") != 0)

   546                     continue;

   547 

   548                   value_node = lm_message_node_get_child (field, "value");

   549                   if (value_node == NULL)

   550                     continue;

   551 

   552                   str = lm_message_node_get_value (value_node);

   553                   if (str == NULL)

   554                     {

   555                       str = "";

   556                     }

   557 

   558                   prop_id = ROOM_PROP_DESCRIPTION;

   559                   g_value_init (&val, G_TYPE_STRING);

   560                   g_value_set_string (&val, str);

   561                 }

   562             }

   563         }

   564 

   565       if (prop_id != INVALID_ROOM_PROP)

   566         {

   567           gabble_properties_mixin_change_value (G_OBJECT (chan), prop_id, &val,

   568                                                 &changed_props_val);

   569 

   570           gabble_properties_mixin_change_flags (G_OBJECT (chan), prop_id,

   571                                                 TP_PROPERTY_FLAG_READ,

   572                                                 0, &changed_props_flags);

   573 

   574           g_value_unset (&val);

   575         }

   576     }

   577 

   578   /*

   579    * Emit signals.

   580    */

   581   gabble_properties_mixin_emit_changed (G_OBJECT (chan), &changed_props_val);

   582   gabble_properties_mixin_emit_flags (G_OBJECT (chan), &changed_props_flags);

   583 }

   584 

   585 static void

   586 room_properties_update (GabbleMucChannel *chan)

   587 {

   588   GabbleMucChannelPrivate *priv;

   589   GError *error = NULL;

   590 

   591   g_assert (GABBLE_IS_MUC_CHANNEL (chan));

   592 

   593   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   594 

   595   if (gabble_disco_request (priv->conn->disco, GABBLE_DISCO_TYPE_INFO,

   596         priv->jid, NULL, properties_disco_cb, chan, G_OBJECT (chan),

   597         &error) == NULL)

   598     {

   599       g_warning ("%s: disco query failed: '%s'", G_STRFUNC, error->message);

   600       g_error_free (error);

   601     }

   602 }

   603 

   604 static void

   605 contact_handle_to_room_identity (GabbleMucChannel *chan, GabbleHandle main_handle,

   606                                  GabbleHandle *room_handle, GString **room_jid)

   607 {

   608   GabbleMucChannelPrivate *priv;

   609   GabbleHandleRepo *handles;

   610   const gchar *main_jid;

   611   gchar *username, *server;

   612   gchar *jid;

   613 

   614   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   615 

   616   handles = priv->conn->handles;

   617 

   618   main_jid = gabble_handle_inspect (handles, TP_HANDLE_TYPE_CONTACT,

   619                                     main_handle);

   620 

   621   gabble_decode_jid (main_jid, &username, &server, NULL);

   622 

   623   jid = g_strdup_printf ("%s/%s", priv->jid, username);

   624 

   625   g_free (username);

   626   g_free (server);

   627 

   628   if (room_handle)

   629     {

   630       *room_handle = gabble_handle_for_contact (handles, jid, TRUE);

   631     }

   632 

   633   if (room_jid)

   634     {

   635       *room_jid = g_string_new (jid);

   636     }

   637 

   638   g_free (jid);

   639 }

   640 

   641 static gboolean

   642 send_join_request (GabbleMucChannel *channel,

   643                    const gchar *password,

   644                    GError **error)

   645 {

   646   GabbleMucChannelPrivate *priv;

   647   LmMessage *msg;

   648   LmMessageNode *x_node;

   649   gboolean ret;

   650 

   651   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (channel);

   652 

   653   /* build the message */

   654   msg = lm_message_new (priv->self_jid->str, LM_MESSAGE_TYPE_PRESENCE);

   655 

   656   x_node = lm_message_node_add_child (msg->node, "x", NULL);

   657   lm_message_node_set_attribute (x_node, "xmlns", NS_MUC);

   658 

   659   g_free (priv->password);

   660 

   661   if (password != NULL)

   662     {

   663       priv->password = g_strdup (password);

   664       lm_message_node_add_child (x_node, "password", password);

   665     }

   666 

   667   /* send it */

   668   ret = _gabble_connection_send (priv->conn, msg, error);

   669   if (!ret)

   670     {

   671       g_warning ("%s: _gabble_connection_send_with_reply failed", G_STRFUNC);

   672     }

   673   else

   674     {

   675       gabble_debug (DEBUG_FLAG, "join request sent");

   676     }

   677 

   678   lm_message_unref (msg);

   679 

   680   return ret;

   681 }

   682 

   683 static gboolean

   684 send_leave_message (GabbleMucChannel *channel,

   685                     const gchar *reason)

   686 {

   687   GabbleMucChannelPrivate *priv;

   688   LmMessage *msg;

   689   GError *error = NULL;

   690   gboolean ret;

   691 

   692   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (channel);

   693 

   694   /* build the message */

   695   msg = lm_message_new_with_sub_type (priv->self_jid->str,

   696                                       LM_MESSAGE_TYPE_PRESENCE,

   697                                       LM_MESSAGE_SUB_TYPE_UNAVAILABLE);

   698 

   699   if (reason != NULL)

   700     {

   701       lm_message_node_add_child (msg->node, "status", reason);

   702     }

   703 

   704   /* send it */

   705   ret = _gabble_connection_send (priv->conn, msg, &error);

   706   if (!ret)

   707     {

   708       g_warning ("%s: _gabble_connection_send_with_reply failed", G_STRFUNC);

   709       g_error_free (error);

   710     }

   711   else

   712     {

   713       gabble_debug (DEBUG_FLAG, "leave message sent");

   714     }

   715 

   716   lm_message_unref (msg);

   717 

   718   return ret;

   719 }

   720 

   721 static void

   722 gabble_muc_channel_get_property (GObject    *object,

   723                                  guint       property_id,

   724                                  GValue     *value,

   725                                  GParamSpec *pspec)

   726 {

   727   GabbleMucChannel *chan = GABBLE_MUC_CHANNEL (object);

   728   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   729 

   730   switch (property_id) {

   731     case PROP_OBJECT_PATH:

   732       g_value_set_string (value, priv->object_path);

   733       break;

   734     case PROP_CHANNEL_TYPE:

   735       g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_TEXT);

   736       break;

   737     case PROP_HANDLE_TYPE:

   738       g_value_set_uint (value, TP_HANDLE_TYPE_ROOM);

   739       break;

   740     case PROP_HANDLE:

   741       g_value_set_uint (value, priv->handle);

   742       break;

   743     case PROP_CONNECTION:

   744       g_value_set_object (value, priv->conn);

   745       break;

   746     case PROP_STATE:

   747       g_value_set_uint (value, priv->state);

   748       break;

   749     default:

   750       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   751       break;

   752   }

   753 }

   754 

   755 static void channel_state_changed (GabbleMucChannel *chan,

   756                                    GabbleMucState prev_state,

   757                                    GabbleMucState new_state);

   758 

   759 static void

   760 gabble_muc_channel_set_property (GObject     *object,

   761                                  guint        property_id,

   762                                  const GValue *value,

   763                                  GParamSpec   *pspec)

   764 {

   765   GabbleMucChannel *chan = GABBLE_MUC_CHANNEL (object);

   766   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   767   GabbleMucState prev_state;

   768 

   769   switch (property_id) {

   770     case PROP_OBJECT_PATH:

   771       g_free (priv->object_path);

   772       priv->object_path = g_value_dup_string (value);

   773       break;

   774     case PROP_HANDLE:

   775       priv->handle = g_value_get_uint (value);

   776       break;

   777     case PROP_CONNECTION:

   778       priv->conn = g_value_get_object (value);

   779       break;

   780     case PROP_STATE:

   781       prev_state = priv->state;

   782       priv->state = g_value_get_uint (value);

   783 

   784       if (priv->state != prev_state)

   785         channel_state_changed (chan, prev_state, priv->state);

   786 

   787       break;

   788     case PROP_INVITE_SELF:

   789       priv->invite_self = g_value_get_boolean (value);

   790       break;

   791     default:

   792       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   793       break;

   794   }

   795 }

   796 

   797 static void gabble_muc_channel_dispose (GObject *object);

   798 static void gabble_muc_channel_finalize (GObject *object);

   799 static gboolean gabble_muc_channel_add_member (GObject *obj, GabbleHandle handle, const gchar *message, GError **error);

   800 static gboolean gabble_muc_channel_remove_member (GObject *obj, GabbleHandle handle, const gchar *message, GError **error);

   801 static gboolean gabble_muc_channel_do_set_properties (GObject *obj, GabblePropertiesContext *ctx, GError **error);

   802 

   803 static void

   804 gabble_muc_channel_class_init (GabbleMucChannelClass *gabble_muc_channel_class)

   805 {

   806   GObjectClass *object_class = G_OBJECT_CLASS (gabble_muc_channel_class);

   807   GParamSpec *param_spec;

   808 

   809   g_type_class_add_private (gabble_muc_channel_class, sizeof (GabbleMucChannelPrivate));

   810 

   811   object_class->constructor = gabble_muc_channel_constructor;

   812 

   813   object_class->get_property = gabble_muc_channel_get_property;

   814   object_class->set_property = gabble_muc_channel_set_property;

   815 

   816   object_class->dispose = gabble_muc_channel_dispose;

   817   object_class->finalize = gabble_muc_channel_finalize;

   818 

   819   g_object_class_override_property (object_class, PROP_OBJECT_PATH, "object-path");

   820   g_object_class_override_property (object_class, PROP_CHANNEL_TYPE, "channel-type");

   821   g_object_class_override_property (object_class, PROP_HANDLE_TYPE, "handle-type");

   822   g_object_class_override_property (object_class, PROP_HANDLE, "handle");

   823 

   824   param_spec = g_param_spec_object ("connection", "GabbleConnection object",

   825                                     "Gabble connection object that owns this "

   826                                     "MUC channel object.",

   827                                     GABBLE_TYPE_CONNECTION,

   828                                     G_PARAM_CONSTRUCT_ONLY |

   829                                     G_PARAM_READWRITE |

   830                                     G_PARAM_STATIC_NICK |

   831                                     G_PARAM_STATIC_BLURB);

   832   g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);

   833 

   834   param_spec = g_param_spec_uint ("state", "Channel state",

   835                                   "The current state that the channel is in.",

   836                                   0, G_MAXUINT32, 0,

   837                                   G_PARAM_READWRITE |

   838                                   G_PARAM_STATIC_NAME |

   839                                   G_PARAM_STATIC_BLURB);

   840   g_object_class_install_property (object_class, PROP_STATE, param_spec);

   841 

   842   param_spec = g_param_spec_boolean ("invite-self", "Invite self",

   843                                      "Whether the user should be added to members list.",

   844                                      FALSE,

   845                                      G_PARAM_CONSTRUCT_ONLY |

   846                                      G_PARAM_WRITABLE |

   847                                      G_PARAM_STATIC_NAME |

   848                                      G_PARAM_STATIC_BLURB);

   849   g_object_class_install_property (object_class, PROP_INVITE_SELF, param_spec);

   850 

   851   signals[READY] =

   852     g_signal_new ("ready",

   853                   G_OBJECT_CLASS_TYPE (gabble_muc_channel_class),

   854                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   855                   0,

   856                   NULL, NULL,

   857                   g_cclosure_marshal_VOID__VOID,

   858                   G_TYPE_NONE, 0);

   859 

   860   signals[JOIN_ERROR] =

   861     g_signal_new ("join-error",

   862                   G_OBJECT_CLASS_TYPE (gabble_muc_channel_class),

   863                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   864                   0,

   865                   NULL, NULL,

   866                   g_cclosure_marshal_VOID__POINTER,

   867                   G_TYPE_NONE, 1, G_TYPE_POINTER);

   868 

   869   signals[CLOSED] =

   870     g_signal_new ("closed",

   871                   G_OBJECT_CLASS_TYPE (gabble_muc_channel_class),

   872                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   873                   0,

   874                   NULL, NULL,

   875                   g_cclosure_marshal_VOID__VOID,

   876                   G_TYPE_NONE, 0);

   877 

   878   signals[PASSWORD_FLAGS_CHANGED] =

   879     g_signal_new ("password-flags-changed",

   880                   G_OBJECT_CLASS_TYPE (gabble_muc_channel_class),

   881                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   882                   0,

   883                   NULL, NULL,

   884                   gabble_muc_channel_marshal_VOID__UINT_UINT,

   885                   G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);

   886 

   887   gabble_group_mixin_class_init (object_class,

   888                                  G_STRUCT_OFFSET (GabbleMucChannelClass, group_class),

   889                                  gabble_muc_channel_add_member,

   890                                  gabble_muc_channel_remove_member);

   891 

   892   gabble_properties_mixin_class_init (object_class,

   893                                       G_STRUCT_OFFSET (GabbleMucChannelClass, properties_class),

   894                                       room_property_signatures, NUM_ROOM_PROPS,

   895                                       gabble_muc_channel_do_set_properties);

   896 

   897   gabble_text_mixin_class_init (object_class, G_STRUCT_OFFSET (GabbleMucChannelClass, text_class));

   898 

   899   dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_muc_channel_class), &dbus_glib_gabble_muc_channel_object_info);

   900 }

   901 

   902 static void clear_join_timer (GabbleMucChannel *chan);

   903 static void clear_poll_timer (GabbleMucChannel *chan);

   904 

   905 void

   906 gabble_muc_channel_dispose (GObject *object)

   907 {

   908   GabbleMucChannel *self = GABBLE_MUC_CHANNEL (object);

   909   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (self);

   910 

   911   if (priv->dispose_has_run)

   912     return;

   913 

   914   gabble_debug (DEBUG_FLAG, "called");

   915 

   916   priv->dispose_has_run = TRUE;

   917 

   918   clear_join_timer (self);

   919   clear_poll_timer (self);

   920 

   921   if (G_OBJECT_CLASS (gabble_muc_channel_parent_class)->dispose)

   922     G_OBJECT_CLASS (gabble_muc_channel_parent_class)->dispose (object);

   923 }

   924 

   925 void

   926 gabble_muc_channel_finalize (GObject *object)

   927 {

   928   GabbleMucChannel *self = GABBLE_MUC_CHANNEL (object);

   929   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (self);

   930   GabbleHandleRepo *handles = priv->conn->handles;

   931 

   932   gabble_debug (DEBUG_FLAG, "called");

   933 

   934   /* free any data held directly by the object here */

   935   gabble_handle_unref (handles, TP_HANDLE_TYPE_ROOM, priv->handle);

   936 

   937   g_free (priv->object_path);

   938 

   939   if (priv->self_jid)

   940     {

   941       g_string_free (priv->self_jid, TRUE);

   942     }

   943 

   944   g_free (priv->password);

   945 

   946   gabble_properties_mixin_finalize (object);

   947 

   948   gabble_group_mixin_finalize (object);

   949 

   950   gabble_text_mixin_finalize (object);

   951 

   952   G_OBJECT_CLASS (gabble_muc_channel_parent_class)->finalize (object);

   953 }

   954 

   955 static void clear_join_timer (GabbleMucChannel *chan)

   956 {

   957   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   958 

   959   if (priv->join_timer_id != 0)

   960     {

   961       g_source_remove (priv->join_timer_id);

   962       priv->join_timer_id = 0;

   963     }

   964 }

   965 

   966 static void clear_poll_timer (GabbleMucChannel *chan)

   967 {

   968   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   969 

   970   if (priv->poll_timer_id != 0)

   971     {

   972       g_source_remove (priv->poll_timer_id);

   973       priv->poll_timer_id = 0;

   974     }

   975 }

   976 

   977 static void

   978 change_password_flags (GabbleMucChannel *chan,

   979                        TpChannelPasswordFlags add,

   980                        TpChannelPasswordFlags remove)

   981 {

   982   GabbleMucChannelPrivate *priv;

   983   TpChannelPasswordFlags added, removed;

   984 

   985   g_assert (GABBLE_IS_MUC_CHANNEL (chan));

   986 

   987   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

   988 

   989   added = add & ~priv->password_flags;

   990   priv->password_flags |= added;

   991 

   992   removed = remove & priv->password_flags;

   993   priv->password_flags &= ~removed;

   994 

   995   if (add != 0 || remove != 0)

   996     {

   997       gabble_debug (DEBUG_FLAG, "emitting password flags changed, added 0x%X, removed 0x%X",

   998               added, removed);

   999 

  1000       g_signal_emit (chan, signals[PASSWORD_FLAGS_CHANGED], 0, added, removed);

  1001     }

  1002 }

  1003 

  1004 static void

  1005 provide_password_return_if_pending (GabbleMucChannel *chan, gboolean success)

  1006 {

  1007   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

  1008 

  1009   if (priv->password_ctx)

  1010     {

  1011       dbus_g_method_return (priv->password_ctx, success);

  1012       priv->password_ctx = NULL;

  1013     }

  1014 

  1015   if (success)

  1016     {

  1017       change_password_flags (chan, 0, TP_CHANNEL_PASSWORD_FLAG_PROVIDE);

  1018     }

  1019 }

  1020 

  1021 static void close_channel (GabbleMucChannel *chan, const gchar *reason, gboolean inform_muc, GabbleHandle actor, guint reason_code);

  1022 

  1023 static gboolean

  1024 timeout_join (gpointer data)

  1025 {

  1026   GabbleMucChannel *chan = data;

  1027 

  1028   gabble_debug (DEBUG_FLAG, "join timed out, closing channel");

  1029 

  1030   provide_password_return_if_pending (chan, FALSE);

  1031 

  1032   close_channel (chan, NULL, FALSE, 0, 0);

  1033 

  1034   return FALSE;

  1035 }

  1036 

  1037 static gboolean

  1038 timeout_poll (gpointer data)

  1039 {

  1040   GabbleMucChannel *chan = data;

  1041 

  1042   gabble_debug (DEBUG_FLAG, "polling for room properties");

  1043 

  1044   room_properties_update (chan);

  1045 

  1046   return TRUE;

  1047 }

  1048 

  1049 static void

  1050 channel_state_changed (GabbleMucChannel *chan,

  1051                        GabbleMucState prev_state,

  1052                        GabbleMucState new_state)

  1053 {

  1054   GabbleMucChannelPrivate *priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

  1055 

  1056   gabble_debug (DEBUG_FLAG, "state changed from %s to %s", muc_states[prev_state], muc_states[new_state]);

  1057 

  1058   if (new_state == MUC_STATE_INITIATED)

  1059     {

  1060       priv->join_timer_id =

  1061         g_timeout_add (DEFAULT_JOIN_TIMEOUT, timeout_join, chan);

  1062     }

  1063   else if (new_state == MUC_STATE_JOINED)

  1064     {

  1065       gboolean low_bandwidth;

  1066       gint interval;

  1067 

  1068       provide_password_return_if_pending (chan, TRUE);

  1069 

  1070       clear_join_timer (chan);

  1071 

  1072       g_object_get (priv->conn, "low-bandwidth", &low_bandwidth, NULL);

  1073 

  1074       if (low_bandwidth)

  1075         interval = PROPS_POLL_INTERVAL_LOW;

  1076       else

  1077         interval = PROPS_POLL_INTERVAL_HIGH;

  1078 

  1079       priv->poll_timer_id = g_timeout_add (interval, timeout_poll, chan);

  1080 

  1081       /* no need to keep this around any longer, if it's set */

  1082       g_free (priv->password);

  1083       priv->password = NULL;

  1084     }

  1085   else if (new_state == MUC_STATE_ENDED)

  1086     {

  1087       clear_poll_timer (chan);

  1088     }

  1089 

  1090   if (new_state == MUC_STATE_JOINED || new_state == MUC_STATE_AUTH)

  1091     {

  1092       if (!priv->ready_emitted)

  1093         {

  1094           g_signal_emit (chan, signals[READY], 0);

  1095 

  1096           priv->ready_emitted = TRUE;

  1097         }

  1098     }

  1099 }

  1100 

  1101 

  1102 static void

  1103 close_channel (GabbleMucChannel *chan, const gchar *reason,

  1104                gboolean inform_muc, GabbleHandle actor, guint reason_code)

  1105 {

  1106   GabbleMucChannelPrivate *priv;

  1107   GIntSet *set;

  1108 

  1109   g_assert (GABBLE_IS_MUC_CHANNEL (chan));

  1110 

  1111   priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

  1112 

  1113   if (priv->closed)

  1114     return;

  1115 

  1116   priv->closed = TRUE;

  1117 

  1118   /* Remove us from member list */

  1119   set = g_intset_new ();

  1120   g_intset_add (set, GABBLE_GROUP_MIXIN (chan)->self_handle);

  1121 

  1122   gabble_group_mixin_change_members (G_OBJECT (chan),

  1123                                      (reason != NULL) ? reason : "",

  1124                                      NULL, set, NULL, NULL, actor,

  1125                                      reason_code);

  1126 

  1127   g_intset_destroy (set);

  1128 

  1129   /* Inform the MUC if requested */

  1130   if (inform_muc && priv->state >= MUC_STATE_INITIATED)

  1131     {

  1132       send_leave_message (chan, reason);

  1133     }

  1134 

  1135   /* Update state and emit Closed signal */