1 /*

     2  * gabble-connection.c - Source for GabbleConnection

     3  * Copyright (C) 2005 Collabora Ltd.

     4  *  and/or its subsidiary/subsidiaries. All rights reserved.

     5  *

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

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

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

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

    10  *

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

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

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

    14  * Lesser General Public License for more details.

    15  *

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

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

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

    19  */

    20 

    21 #include "config.h"

    22 

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

    24 #include <dbus/dbus-glib-lowlevel.h>

    25 #include <glib-object.h>

    26 #include "loudmouth/loudmouth.h"

    27 #include <stdlib.h>

    28 #include <string.h>

    29 #include <stdio.h>

    30 

    31 

    32 #include "handles.h"

    33 #include "handle-set.h"

    34 #include "telepathy-constants.h"

    35 #include "telepathy-errors.h"

    36 #include "telepathy-helpers.h"

    37 #include "telepathy-interfaces.h"

    38 #include "loudmouth/lm-connection.h"

    39 

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

    41 #include "tp-channel-factory-iface.h"

    42 

    43 #include "gabble-connection.h"

    44 #include "gabble-connection-glue.h"

    45 #include "gabble-connection-signals-marshal.h"

    46 

    47 

    48 #include "capabilities.h"

    49 #include "debug.h"

    50 #include "disco.h"

    51 #include "gabble-presence-cache.h"

    52 #include "gabble-presence.h"

    53 #include "gabble-register.h"

    54 #include "im-factory.h"

    55 #include "search-factory.h"

    56 #include "jingle-info.h"

    57 #include "media-factory.h"

    58 #include "muc-factory.h"

    59 #include "namespaces.h"

    60 #include "roster.h"

    61 #include "util.h"

    62 #include "vcard-manager.h"

    63 #include "search-keys-info.h"

    64 

    65 #include "gabble-media-channel.h"

    66 #include "gabble-roomlist-channel.h"

    67 

    68 #include "gabble_enums.h"

    69 #include "sha1.h"

    70 #include "base64.h"

    71 

    72 #define DEBUG_FLAG GABBLE_DEBUG_CONNECTION

    73 #define DBUS_API_SUBJECT_TO_CHANGE

    74 #define BUS_NAME        "org.freedesktop.Telepathy.Connection.gabble"

    75 #define OBJECT_PATH     "/org/freedesktop/Telepathy/Connection/gabble"

    76 

    77 #define TP_ALIAS_PAIR_TYPE (dbus_g_type_get_struct ("GValueArray", \

    78       G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID))

    79 #define TP_CAPABILITY_PAIR_TYPE (dbus_g_type_get_struct ("GValueArray", \

    80       G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID))

    81 #define TP_CAPABILITIES_CHANGED_MONSTER_TYPE (dbus_g_type_get_struct \

    82     ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

    83                     G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID))

    84 #define TP_GET_CAPABILITIES_MONSTER_TYPE (dbus_g_type_get_struct \

    85     ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

    86                     G_TYPE_INVALID))

    87 #define TP_CHANNEL_LIST_ENTRY_TYPE (dbus_g_type_get_struct ("GValueArray", \

    88       DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

    89       G_TYPE_INVALID))

    90 

    91 #define ERROR_IF_NOT_CONNECTED(CONN, ERROR) \

    92   if ((CONN)->status != TP_CONN_STATUS_CONNECTED) \

    93     { \

    94       gabble_debug (DEBUG_FLAG, "rejected request as disconnected"); \

    95       g_set_error (ERROR, TELEPATHY_ERRORS, NotAvailable, \

    96           "Connection is disconnected"); \

    97       return FALSE; \

    98     }

    99 

   100 #define ERROR_IF_NOT_CONNECTED_ASYNC(CONN, ERROR, CONTEXT) \

   101   if ((CONN)->status != TP_CONN_STATUS_CONNECTED) \

   102     { \

   103       gabble_debug (DEBUG_FLAG, "rejected request as disconnected"); \

   104       (ERROR) = g_error_new (TELEPATHY_ERRORS, NotAvailable, \

   105           "Connection is disconnected"); \

   106       dbus_g_method_return_error ((CONTEXT), (ERROR)); \

   107       g_error_free ((ERROR)); \

   108       return; \

   109     }

   110 

   111 #ifdef DEBUG_FLAG

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

   113 #define DEBUGGING 0

   114 #define NODE_DEBUG(n, s)

   115 #endif /* DEBUG_FLAG */

   116 

   117 #ifndef EMULATOR

   118 G_DEFINE_TYPE(GabbleConnection, gabble_connection, G_TYPE_OBJECT)

   119 #endif

   120 

   121 typedef struct _StatusInfo StatusInfo;

   122 

   123 struct _StatusInfo

   124 {

   125   const gchar *name;

   126   TpConnectionPresenceType presence_type;

   127   const gboolean self;

   128   const gboolean exclusive;

   129 };

   130 

   131 /* order must match PresenceId enum in gabble-connection.h */

   132 /* in increasing order of presence */

   133 static const StatusInfo gabble_statuses[LAST_GABBLE_PRESENCE] = {

   134  { "offline",   TP_CONN_PRESENCE_TYPE_OFFLINE,       TRUE, TRUE },

   135  { "hidden",    TP_CONN_PRESENCE_TYPE_HIDDEN,        TRUE, TRUE },

   136  { "xa",        TP_CONN_PRESENCE_TYPE_EXTENDED_AWAY, TRUE, TRUE },

   137  { "away",      TP_CONN_PRESENCE_TYPE_AWAY,          TRUE, TRUE },

   138  { "dnd",       TP_CONN_PRESENCE_TYPE_AWAY,          TRUE, TRUE },

   139  { "available", TP_CONN_PRESENCE_TYPE_AVAILABLE,     TRUE, TRUE },

   140  { "chat",      TP_CONN_PRESENCE_TYPE_AVAILABLE,     TRUE, TRUE }

   141 };

   142 

   143 /* signal enum */

   144 enum

   145 {

   146     ALIASES_CHANGED,

   147     CAPABILITIES_CHANGED,

   148     NEW_CHANNEL,

   149     PRESENCE_UPDATE,

   150     STATUS_CHANGED,

   151     DISCONNECTED,

   152     LAST_SIGNAL 

   153 #ifdef EMULATOR    

   154     = LAST_SIGNAL_CON

   155 #endif

   156     

   157 };

   158 

   159 

   160 #ifdef EMULATOR

   161 #include "libgabble_wsd_solution.h"

   162 

   163 	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_con,guint)

   164 	#define signals (GET_WSD_VAR_NAME(signals,gabble_con, s)())	

   165 	

   166 	

   167 	GET_STATIC_VAR_FROM_TLS(arguments,gabble_con,GHashTable*)

   168 	#define arguments (*GET_WSD_VAR_NAME(arguments,gabble_con, s)())	

   169 	

   170 	GET_STATIC_VAR_FROM_TLS(gabble_connection_parent_class,gabble_con,gpointer)

   171 	#define gabble_connection_parent_class (*GET_WSD_VAR_NAME(gabble_connection_parent_class,gabble_con,s)())

   172 	

   173 	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_con,GType)

   174 	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_con,s)())

   175 	

   176 	//GET_STATIC_ARRAY_FROM_TLS(assumed_caps,gabble_con,gchar*)

   177 	/*gchar** _s_gabble_con_assumed_caps() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_con_assumed_caps)); }

   178 

   179 	#define assumed_caps (GET_WSD_VAR_NAME(assumed_caps,gabble_con, s)())	*/

   180 	

   181 	

   182 			

   183 static void gabble_connection_init (GabbleConnection *self); 

   184 static void gabble_connection_class_init (GabbleConnectionClass *klass); 

   185 static void gabble_connection_class_intern_init (gpointer klass) 

   186 { 

   187 gabble_connection_parent_class = g_type_class_peek_parent (klass); 

   188 gabble_connection_class_init ((GabbleConnectionClass*) klass); 

   189 } 

   190 EXPORT_C GType gabble_connection_get_type (void) 

   191 { 

   192 

   193 if ((g_define_type_id == 0)) 

   194 { 

   195 static const GTypeInfo g_define_type_info = 

   196 	{ sizeof (GabbleConnectionClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_connection_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleConnection), 0, (GInstanceInitFunc) gabble_connection_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleConnection"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

   197 	} ;

   198 	

   199 #else

   200 

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

   202 

   203 #endif	

   204 

   205 /* properties */

   206 enum

   207 {

   208     PROP_PROTOCOL = 1,

   209     PROP_CONNECT_SERVER,

   210     PROP_PORT,

   211     PROP_OLD_SSL,

   212     PROP_REGISTER,

   213     PROP_LOW_BANDWIDTH,

   214     PROP_STREAM_SERVER,

   215     PROP_USERNAME,

   216     PROP_PASSWORD,

   217     PROP_RESOURCE,

   218     PROP_PRIORITY,

   219     PROP_HTTPS_PROXY_SERVER,

   220     PROP_HTTPS_PROXY_PORT,

   221     PROP_FALLBACK_CONFERENCE_SERVER,

   222     PROP_STUN_SERVER,

   223     PROP_STUN_PORT,

   224     PROP_STUN_RELAY_MAGIC_COOKIE,

   225     PROP_STUN_RELAY_SERVER,

   226     PROP_STUN_RELAY_UDP_PORT,

   227     PROP_STUN_RELAY_TCP_PORT,

   228     PROP_STUN_RELAY_SSLTCP_PORT,

   229     PROP_STUN_RELAY_USERNAME,

   230     PROP_STUN_RELAY_PASSWORD,

   231     PROP_IGNORE_SSL_ERRORS,

   232     PROP_ALIAS,

   233 

   234     LAST_PROPERTY

   235 };

   236 

   237 /* TP properties */

   238 enum

   239 {

   240   CONN_PROP_STUN_SERVER = 0,

   241   CONN_PROP_STUN_PORT,

   242   CONN_PROP_STUN_RELAY_MAGIC_COOKIE,

   243   CONN_PROP_STUN_RELAY_SERVER,

   244   CONN_PROP_STUN_RELAY_UDP_PORT,

   245   CONN_PROP_STUN_RELAY_TCP_PORT,

   246   CONN_PROP_STUN_RELAY_SSLTCP_PORT,

   247   CONN_PROP_STUN_RELAY_USERNAME,

   248   CONN_PROP_STUN_RELAY_PASSWORD,

   249 

   250   NUM_CONN_PROPS,

   251 

   252   INVALID_CONN_PROP,

   253 };

   254 

   255 const GabblePropertySignature connection_property_signatures[NUM_CONN_PROPS] = {

   256       { "stun-server",                  G_TYPE_STRING },

   257       { "stun-port",                    G_TYPE_UINT   },

   258       { "stun-relay-magic-cookie",      G_TYPE_STRING },

   259       { "stun-relay-server",            G_TYPE_STRING },

   260       { "stun-relay-udp-port",          G_TYPE_UINT   },

   261       { "stun-relay-tcp-port",          G_TYPE_UINT   },

   262       { "stun-relay-ssltcp-port",       G_TYPE_UINT   },

   263       { "stun-relay-username",          G_TYPE_STRING },

   264       { "stun-relay-password",          G_TYPE_STRING },

   265 };

   266 

   267 /* private structure */

   268 typedef struct _GabbleConnectionPrivate GabbleConnectionPrivate;

   269 

   270 struct _GabbleConnectionPrivate

   271 {

   272   LmMessageHandler *iq_jingle_info_cb;

   273   LmMessageHandler *iq_search_keys_cb;

   274   LmMessageHandler *iq_disco_cb;

   275   LmMessageHandler *iq_unknown_cb;

   276   LmMessageHandler *stream_error_cb;

   277 

   278   /* telepathy properties */

   279   gchar *protocol;

   280 

   281   /* connection properties */

   282   gchar *connect_server;

   283   guint port;

   284   gboolean old_ssl;

   285 

   286   gboolean ignore_ssl_errors;

   287   TpConnectionStatusReason ssl_error;

   288 

   289   gboolean do_register;

   290 

   291   gboolean low_bandwidth;

   292 

   293   gchar *https_proxy_server;

   294   guint https_proxy_port;

   295 

   296   gchar *fallback_conference_server;

   297 

   298   /* authentication properties */

   299   gchar *stream_server;

   300   gchar *username;

   301   gchar *password;

   302   gchar *resource;

   303   gint8 priority;

   304   gchar *alias;

   305 

   306   /* reference to conference server name */

   307   const gchar *conference_server;

   308 

   309   /* channel factories */

   310   GPtrArray *channel_factories;

   311   GPtrArray *channel_requests;

   312   gboolean suppress_next_handler;

   313 

   314   /* serial number of current advertised caps */

   315   guint caps_serial;

   316 

   317   /* gobject housekeeping */

   318   gboolean dispose_has_run;

   319 };

   320 

   321 #define GABBLE_CONNECTION_GET_PRIVATE(obj) \

   322     ((GabbleConnectionPrivate *)obj->priv)

   323 

   324 typedef struct _ChannelRequest ChannelRequest;

   325 

   326 struct _ChannelRequest

   327 {

   328   DBusGMethodInvocation *context;

   329   gchar *channel_type;

   330   guint handle_type;

   331   guint handle;

   332   gboolean suppress_handler;

   333 };

   334 

   335 static void connection_new_channel_cb (TpChannelFactoryIface *, GObject *, gpointer);

   336 static void connection_channel_error_cb (TpChannelFactoryIface *, GObject *, GError *, gpointer);

   337 static void connection_nickname_update_cb (GObject *, GabbleHandle, gpointer);

   338 static void connection_presence_update_cb (GabblePresenceCache *, GabbleHandle, gpointer);

   339 static void connection_capabilities_update_cb (GabblePresenceCache *, GabbleHandle, GabblePresenceCapabilities, GabblePresenceCapabilities, gpointer);

   340 

   341 static void

   342 gabble_connection_init (GabbleConnection *self)

   343 {

   344   GabbleConnectionPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

   345       GABBLE_TYPE_CONNECTION, GabbleConnectionPrivate);

   346   guint i;

   347   GValue val = { 0, };

   348 

   349   self->priv = priv;

   350   self->lmconn = lm_connection_new (NULL);

   351   self->status = TP_CONN_STATUS_NEW;

   352   self->handles = gabble_handle_repo_new ();

   353   self->disco = gabble_disco_new (self);

   354   self->vcard_manager = gabble_vcard_manager_new (self);

   355   self->search_instr = NULL;

   356   self->search_key_names = NULL;

   357   self->search_reported_fields = NULL;

   358   self->search_form = FALSE;

   359   self->search_service_jid = NULL;

   360   self->self_avatar_sha1 = NULL;

   361   self->self_handle = 0;

   362   g_signal_connect (self->vcard_manager, "nickname-update", G_CALLBACK

   363       (connection_nickname_update_cb), self);

   364 

   365   self->presence_cache = gabble_presence_cache_new (self);

   366   g_signal_connect (self->presence_cache, "nickname-update", G_CALLBACK

   367       (connection_nickname_update_cb), self);

   368   g_signal_connect (self->presence_cache, "presence-update", G_CALLBACK

   369       (connection_presence_update_cb), self);

   370   g_signal_connect (self->presence_cache, "capabilities-update", G_CALLBACK

   371       (connection_capabilities_update_cb), self);

   372 

   373   capabilities_fill_cache (self->presence_cache);

   374 

   375   self->roster = gabble_roster_new (self);

   376   g_signal_connect (self->roster, "nickname-update", G_CALLBACK

   377       (connection_nickname_update_cb), self);

   378 

   379   priv->channel_factories = g_ptr_array_sized_new (1);

   380 

   381   g_ptr_array_add (priv->channel_factories, self->roster);

   382 

   383   g_ptr_array_add (priv->channel_factories,

   384                    g_object_new (GABBLE_TYPE_MUC_FACTORY,

   385                                  "connection", self,

   386                                  NULL));

   387 

   388   g_ptr_array_add (priv->channel_factories,

   389                    g_object_new (GABBLE_TYPE_MEDIA_FACTORY,

   390                                  "connection", self,

   391                                  NULL));

   392 

   393   g_ptr_array_add (priv->channel_factories,

   394                    g_object_new (GABBLE_TYPE_IM_FACTORY,

   395                                  "connection", self,

   396                                  NULL));

   397                                  

   398   //add for search here	

   399   g_ptr_array_add (priv->channel_factories,

   400                     g_object_new (GABBLE_TYPE_SEARCH_FACTORY,

   401                                  "connection", self,

   402                                  NULL));                               

   403 

   404   for (i = 0; i < priv->channel_factories->len; i++)

   405     {

   406       GObject *factory = g_ptr_array_index (priv->channel_factories, i);

   407       g_signal_connect (factory, "new-channel", G_CALLBACK

   408           (connection_new_channel_cb), self);

   409       g_signal_connect (factory, "channel-error", G_CALLBACK

   410           (connection_channel_error_cb), self);

   411     }

   412 

   413   priv->channel_requests = g_ptr_array_new ();

   414 

   415   /* Set default parameters for optional parameters */

   416   priv->resource = g_strdup (GABBLE_PARAMS_DEFAULT_RESOURCE);

   417   priv->port = GABBLE_PARAMS_DEFAULT_PORT;

   418   priv->https_proxy_port = GABBLE_PARAMS_DEFAULT_HTTPS_PROXY_PORT;

   419 

   420   /* initialize properties mixin */

   421   gabble_properties_mixin_init (G_OBJECT (self), G_STRUCT_OFFSET (

   422         GabbleConnection, properties));

   423 

   424   g_value_init (&val, G_TYPE_UINT);

   425   g_value_set_uint (&val, GABBLE_PARAMS_DEFAULT_STUN_PORT);

   426 

   427   gabble_properties_mixin_change_value (G_OBJECT (self), CONN_PROP_STUN_PORT,

   428                                         &val, NULL);

   429   gabble_properties_mixin_change_flags (G_OBJECT (self), CONN_PROP_STUN_PORT,

   430                                         TP_PROPERTY_FLAG_READ, 0, NULL);

   431 

   432   g_value_unset (&val);

   433 

   434   priv->caps_serial = 1;

   435 }

   436 

   437 static void

   438 gabble_connection_get_property (GObject    *object,

   439                                 guint       property_id,

   440                                 GValue     *value,

   441                                 GParamSpec *pspec)

   442 {

   443   GabbleConnection *self = (GabbleConnection *) object;

   444   GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

   445   const gchar *param_name;

   446   guint tp_property_id;

   447 

   448   switch (property_id) {

   449     case PROP_PROTOCOL:

   450       g_value_set_string (value, priv->protocol);

   451       break;

   452     case PROP_CONNECT_SERVER:

   453       g_value_set_string (value, priv->connect_server);

   454       break;

   455     case PROP_STREAM_SERVER:

   456       g_value_set_string (value, priv->stream_server);

   457       break;

   458     case PROP_PORT:

   459       g_value_set_uint (value, priv->port);

   460       break;

   461     case PROP_OLD_SSL:

   462       g_value_set_boolean (value, priv->old_ssl);

   463       break;

   464     case PROP_REGISTER:

   465       g_value_set_boolean (value, priv->do_register);

   466       break;

   467     case PROP_LOW_BANDWIDTH:

   468       g_value_set_boolean (value, priv->low_bandwidth);

   469       break;

   470     case PROP_USERNAME:

   471       g_value_set_string (value, priv->username);

   472       break;

   473     case PROP_PASSWORD:

   474       g_value_set_string (value, priv->password);

   475       break;

   476     case PROP_RESOURCE:

   477       g_value_set_string (value, priv->resource);

   478       break;

   479     case PROP_PRIORITY:

   480       g_value_set_int (value, priv->priority);

   481       break;

   482     case PROP_HTTPS_PROXY_SERVER:

   483       g_value_set_string (value, priv->https_proxy_server);

   484       break;

   485     case PROP_HTTPS_PROXY_PORT:

   486       g_value_set_uint (value, priv->https_proxy_port);

   487       break;

   488     case PROP_FALLBACK_CONFERENCE_SERVER:

   489       g_value_set_string (value, priv->fallback_conference_server);

   490       break;

   491     case PROP_IGNORE_SSL_ERRORS:

   492       g_value_set_boolean (value, priv->ignore_ssl_errors);

   493       break;

   494     case PROP_ALIAS:

   495       g_value_set_string (value, priv->alias);

   496       break;

   497     default:

   498       param_name = g_param_spec_get_name (pspec);

   499 

   500       if (gabble_properties_mixin_has_property (object, param_name,

   501             &tp_property_id))

   502         {

   503           GValue *tp_property_value =

   504             self->properties.properties[tp_property_id].value;

   505 

   506           if (tp_property_value)

   507             {

   508               g_value_copy (tp_property_value, value);

   509               return;

   510             }

   511         }

   512 

   513       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   514       break;

   515   }

   516 }

   517 

   518 static void

   519 gabble_connection_set_property (GObject      *object,

   520                                 guint         property_id,

   521                                 const GValue *value,

   522                                 GParamSpec   *pspec)

   523 {

   524   GabbleConnection *self = (GabbleConnection *) object;

   525   GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

   526   const gchar *param_name;

   527   guint tp_property_id;

   528 

   529   switch (property_id) {

   530     case PROP_PROTOCOL:

   531       g_free (priv->protocol);

   532       priv->protocol = g_value_dup_string (value);

   533       break;

   534     case PROP_CONNECT_SERVER:

   535       g_free (priv->connect_server);

   536       priv->connect_server = g_value_dup_string (value);

   537       break;

   538     case PROP_PORT:

   539       priv->port = g_value_get_uint (value);

   540       break;

   541     case PROP_OLD_SSL:

   542       priv->old_ssl = g_value_get_boolean (value);

   543       break;

   544     case PROP_REGISTER:

   545       priv->do_register = g_value_get_boolean (value);

   546       break;

   547     case PROP_LOW_BANDWIDTH:

   548       priv->low_bandwidth = g_value_get_boolean (value);

   549       break;

   550     case PROP_STREAM_SERVER:

   551       g_free (priv->stream_server);

   552       priv->stream_server = g_value_dup_string (value);

   553       break;

   554     case PROP_USERNAME:

   555       g_free (priv->username);

   556       priv->username = g_value_dup_string (value);

   557       break;

   558    case PROP_PASSWORD:

   559       g_free (priv->password);

   560       priv->password = g_value_dup_string (value);

   561       break;

   562     case PROP_RESOURCE:

   563       g_free (priv->resource);

   564       priv->resource = g_value_dup_string (value);

   565       break;

   566     case PROP_PRIORITY:

   567       priv->priority = CLAMP (g_value_get_int (value), G_MININT8, G_MAXINT8);

   568       break;

   569     case PROP_HTTPS_PROXY_SERVER:

   570       g_free (priv->https_proxy_server);

   571       priv->https_proxy_server = g_value_dup_string (value);

   572       break;

   573     case PROP_HTTPS_PROXY_PORT:

   574       priv->https_proxy_port = g_value_get_uint (value);

   575       break;

   576     case PROP_FALLBACK_CONFERENCE_SERVER:

   577       g_free (priv->fallback_conference_server);

   578       priv->fallback_conference_server = g_value_dup_string (value);

   579       break;

   580     case PROP_IGNORE_SSL_ERRORS:

   581       priv->ignore_ssl_errors = g_value_get_boolean (value);

   582       break;

   583    case PROP_ALIAS:

   584       g_free (priv->alias);

   585       priv->alias = g_value_dup_string (value);

   586       break;

   587     default:

   588       param_name = g_param_spec_get_name (pspec);

   589 

   590       if (gabble_properties_mixin_has_property (object, param_name,

   591             &tp_property_id))

   592         {

   593           gabble_properties_mixin_change_value (object, tp_property_id, value,

   594                                                 NULL);

   595           gabble_properties_mixin_change_flags (object, tp_property_id,

   596                                                 TP_PROPERTY_FLAG_READ,

   597                                                 0, NULL);

   598 

   599           return;

   600         }

   601 

   602       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   603       break;

   604   }

   605 }

   606 

   607 static void gabble_connection_dispose (GObject *object);

   608 static void gabble_connection_finalize (GObject *object);

   609 

   610 static void

   611 gabble_connection_class_init (GabbleConnectionClass *gabble_connection_class)

   612 {

   613   GObjectClass *object_class = G_OBJECT_CLASS (gabble_connection_class);

   614   GParamSpec *param_spec;

   615 

   616   object_class->get_property = gabble_connection_get_property;

   617   object_class->set_property = gabble_connection_set_property;

   618 

   619   g_type_class_add_private (gabble_connection_class, sizeof (GabbleConnectionPrivate));

   620 

   621   object_class->dispose = gabble_connection_dispose;

   622   object_class->finalize = gabble_connection_finalize;

   623 

   624   param_spec = g_param_spec_string ("protocol", "Telepathy identifier for protocol",

   625                                     "Identifier string used when the protocol "

   626                                     "name is required. Unused internally.",

   627                                     NULL,

   628                                     G_PARAM_READWRITE |

   629                                     G_PARAM_STATIC_NAME |

   630                                     G_PARAM_STATIC_BLURB);

   631   g_object_class_install_property (object_class, PROP_PROTOCOL, param_spec);

   632 

   633   param_spec = g_param_spec_string ("connect-server", "Hostname or IP of Jabber server",

   634                                     "The server used when establishing a connection.",

   635                                     NULL,

   636                                     G_PARAM_READWRITE |

   637                                     G_PARAM_STATIC_NAME |

   638                                     G_PARAM_STATIC_BLURB);

   639   g_object_class_install_property (object_class, PROP_CONNECT_SERVER, param_spec);

   640 

   641   param_spec = g_param_spec_uint ("port", "Jabber server port",

   642                                   "The port used when establishing a connection.",

   643                                   0, G_MAXUINT16, GABBLE_PARAMS_DEFAULT_PORT,

   644                                   G_PARAM_READWRITE |

   645                                   G_PARAM_STATIC_NAME |

   646                                   G_PARAM_STATIC_BLURB);

   647   g_object_class_install_property (object_class, PROP_PORT, param_spec);

   648 

   649   param_spec = g_param_spec_boolean ("old-ssl", "Old-style SSL tunneled connection",

   650                                      "Establish the entire connection to the server "

   651                                      "within an SSL-encrypted tunnel. Note that this "

   652                                      "is not the same as connecting with TLS, which "

   653                                      "is not yet supported.", FALSE,

   654                                      G_PARAM_READWRITE |

   655                                      G_PARAM_STATIC_NAME |

   656                                      G_PARAM_STATIC_BLURB);

   657   g_object_class_install_property (object_class, PROP_OLD_SSL, param_spec);

   658 

   659   param_spec = g_param_spec_boolean ("register", "Register account on server",

   660                                      "Register a new account on server.", FALSE,

   661                                      G_PARAM_READWRITE |

   662                                      G_PARAM_STATIC_NAME |

   663                                      G_PARAM_STATIC_BLURB);

   664   g_object_class_install_property (object_class, PROP_REGISTER, param_spec);

   665 

   666   param_spec = g_param_spec_boolean ("low-bandwidth", "Low bandwidth mode",

   667                                      "Determines whether we are in low "

   668                                      "bandwidth mode. This influences "

   669                                      "polling behaviour.", FALSE,

   670                                      G_PARAM_READWRITE |

   671                                      G_PARAM_STATIC_NAME |

   672                                      G_PARAM_STATIC_BLURB);

   673   g_object_class_install_property (object_class, PROP_LOW_BANDWIDTH, param_spec);

   674 

   675   param_spec = g_param_spec_string ("stream-server", "The server name used to initialise the stream.",

   676                                     "The server name used when initialising the stream, "

   677                                     "which is usually the part after the @ in the user's JID.",

   678                                     NULL,

   679                                     G_PARAM_READWRITE |

   680                                     G_PARAM_STATIC_NAME |

   681                                     G_PARAM_STATIC_BLURB);

   682   g_object_class_install_property (object_class, PROP_STREAM_SERVER, param_spec);

   683 

   684   param_spec = g_param_spec_string ("username", "Jabber username",

   685                                     "The username used when authenticating.",

   686                                     NULL,

   687                                     G_PARAM_READWRITE |

   688                                     G_PARAM_STATIC_NAME |

   689                                     G_PARAM_STATIC_BLURB);

   690   g_object_class_install_property (object_class, PROP_USERNAME, param_spec);

   691 

   692   param_spec = g_param_spec_string ("password", "Jabber password",

   693                                     "The password used when authenticating.",

   694                                     NULL,

   695                                     G_PARAM_READWRITE |

   696                                     G_PARAM_STATIC_NAME |

   697                                     G_PARAM_STATIC_BLURB);

   698   g_object_class_install_property (object_class, PROP_PASSWORD, param_spec);

   699 

   700   param_spec = g_param_spec_string ("resource", "Jabber resource",

   701                                     "The Jabber resource used when authenticating.",

   702                                     "Telepathy",

   703                                     G_PARAM_READWRITE |

   704                                     G_PARAM_STATIC_NAME |

   705                                     G_PARAM_STATIC_BLURB);

   706   g_object_class_install_property (object_class, PROP_RESOURCE, param_spec);

   707 

   708   param_spec = g_param_spec_int ("priority", "Jabber presence priority",

   709                                  "The default priority used when reporting our presence.",

   710                                  G_MININT8, G_MAXINT8, 0,

   711                                  G_PARAM_READWRITE |

   712                                  G_PARAM_STATIC_NAME |

   713                                  G_PARAM_STATIC_BLURB);

   714   g_object_class_install_property (object_class, PROP_PRIORITY, param_spec);

   715 

   716   param_spec = g_param_spec_string ("https-proxy-server", "The server name "

   717                                     "used as an HTTPS proxy server",

   718                                     "The server name used as an HTTPS proxy "

   719                                     "server.",

   720                                     NULL,

   721                                     G_PARAM_READWRITE |

   722                                     G_PARAM_STATIC_NAME |

   723                                     G_PARAM_STATIC_BLURB);

   724   g_object_class_install_property (object_class, PROP_HTTPS_PROXY_SERVER, param_spec);

   725 

   726   param_spec = g_param_spec_uint ("https-proxy-port", "The HTTP proxy server "

   727                                   "port", "The HTTP proxy server port.",

   728                                   0, G_MAXUINT16, 0,

   729                                   G_PARAM_READWRITE |

   730                                   G_PARAM_STATIC_NAME |

   731                                   G_PARAM_STATIC_BLURB);

   732   g_object_class_install_property (object_class, PROP_HTTPS_PROXY_PORT, param_spec);

   733 

   734   param_spec = g_param_spec_string ("fallback-conference-server",

   735                                     "The conference server used as fallback",

   736                                     "The conference server used as fallback when "

   737                                     "everything else fails.",

   738                                     NULL,

   739                                     G_PARAM_READWRITE |

   740                                     G_PARAM_STATIC_NAME |

   741                                     G_PARAM_STATIC_BLURB);

   742   g_object_class_install_property (object_class, PROP_FALLBACK_CONFERENCE_SERVER,

   743                                    param_spec);

   744 

   745   param_spec = g_param_spec_string ("stun-server",

   746                                     "STUN server",

   747                                     "STUN server.",

   748                                     NULL,

   749                                     G_PARAM_READWRITE |

   750                                     G_PARAM_STATIC_NAME |

   751                                     G_PARAM_STATIC_BLURB);

   752   g_object_class_install_property (object_class, PROP_STUN_SERVER, param_spec);

   753 

   754   param_spec = g_param_spec_uint ("stun-port",

   755                                   "STUN port",

   756                                   "STUN port.",

   757                                   0, G_MAXUINT16, 0,

   758                                   G_PARAM_READWRITE |

   759                                   G_PARAM_STATIC_NAME |

   760                                   G_PARAM_STATIC_BLURB);

   761   g_object_class_install_property (object_class, PROP_STUN_PORT, param_spec);

   762 

   763   param_spec = g_param_spec_string ("stun-relay-magic-cookie",

   764                                     "STUN relay magic cookie",

   765                                     "STUN relay magic cookie.",

   766                                     NULL,

   767                                     G_PARAM_READWRITE |

   768                                     G_PARAM_STATIC_NAME |

   769                                     G_PARAM_STATIC_BLURB);

   770   g_object_class_install_property (object_class, PROP_STUN_RELAY_MAGIC_COOKIE,

   771                                    param_spec);

   772 

   773   param_spec = g_param_spec_string ("stun-relay-server",

   774                                     "STUN relay server",

   775                                     "STUN relay server.",

   776                                     NULL,

   777                                     G_PARAM_READWRITE |

   778                                     G_PARAM_STATIC_NAME |

   779                                     G_PARAM_STATIC_BLURB);

   780   g_object_class_install_property (object_class, PROP_STUN_RELAY_SERVER,

   781                                    param_spec);

   782 

   783   param_spec = g_param_spec_uint ("stun-relay-udp-port",

   784                                   "STUN relay UDP port",

   785                                   "STUN relay UDP port.",

   786                                   0, G_MAXUINT16, 0,

   787                                   G_PARAM_READWRITE |

   788                                   G_PARAM_STATIC_NAME |

   789                                   G_PARAM_STATIC_BLURB);

   790   g_object_class_install_property (object_class, PROP_STUN_RELAY_UDP_PORT,

   791                                    param_spec);

   792 

   793   param_spec = g_param_spec_uint ("stun-relay-tcp-port",

   794                                   "STUN relay TCP port",

   795                                   "STUN relay TCP port.",

   796                                   0, G_MAXUINT16, 0,

   797                                   G_PARAM_READWRITE |

   798                                   G_PARAM_STATIC_NAME |

   799                                   G_PARAM_STATIC_BLURB);

   800   g_object_class_install_property (object_class, PROP_STUN_RELAY_TCP_PORT,

   801                                    param_spec);

   802 

   803   param_spec = g_param_spec_uint ("stun-relay-ssltcp-port",

   804                                   "STUN relay SSL-TCP port",

   805                                   "STUN relay SSL-TCP port.",

   806                                   0, G_MAXUINT16, 0,

   807                                   G_PARAM_READWRITE |

   808                                   G_PARAM_STATIC_NAME |

   809                                   G_PARAM_STATIC_BLURB);

   810   g_object_class_install_property (object_class, PROP_STUN_RELAY_SSLTCP_PORT,

   811                                    param_spec);

   812 

   813   param_spec = g_param_spec_string ("stun-relay-username",

   814                                     "STUN relay username",

   815                                     "STUN relay username.",

   816                                     NULL,

   817                                     G_PARAM_READWRITE |

   818                                     G_PARAM_STATIC_NAME |

   819                                     G_PARAM_STATIC_BLURB);

   820   g_object_class_install_property (object_class, PROP_STUN_RELAY_USERNAME,

   821                                    param_spec);

   822 

   823   param_spec = g_param_spec_string ("stun-relay-password",

   824                                     "STUN relay password",

   825                                     "STUN relay password.",

   826                                     NULL,

   827                                     G_PARAM_READWRITE |

   828                                     G_PARAM_STATIC_NAME |

   829                                     G_PARAM_STATIC_BLURB);

   830   g_object_class_install_property (object_class, PROP_STUN_RELAY_PASSWORD,

   831                                    param_spec);

   832 

   833   param_spec = g_param_spec_boolean ("ignore-ssl-errors", "Ignore SSL errors",

   834                                      "Continue connecting even if the server's "

   835                                      "SSL certificate is invalid or missing.",

   836                                      FALSE,

   837                                      G_PARAM_READWRITE |

   838                                      G_PARAM_STATIC_NAME |

   839                                      G_PARAM_STATIC_BLURB);

   840   g_object_class_install_property (object_class, PROP_IGNORE_SSL_ERRORS, param_spec);

   841 

   842   param_spec = g_param_spec_string ("alias",

   843                                     "Alias/nick for local user",

   844                                     "Alias/nick for local user",

   845                                     NULL,

   846                                     G_PARAM_READWRITE |

   847                                     G_PARAM_STATIC_NAME |

   848                                     G_PARAM_STATIC_BLURB);

   849   g_object_class_install_property (object_class, PROP_ALIAS, param_spec);

   850 

   851   /* signal definitions */

   852 

   853   signals[ALIASES_CHANGED] =

   854     g_signal_new ("aliases-changed",

   855                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   856                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   857                   0,

   858                   NULL, NULL,

   859                   g_cclosure_marshal_VOID__BOXED,

   860                   G_TYPE_NONE, 1, (dbus_g_type_get_collection ("GPtrArray", (dbus_g_type_get_struct ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID)))));

   861 

   862   signals[CAPABILITIES_CHANGED] =

   863     g_signal_new ("capabilities-changed",

   864                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   865                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   866                   0,

   867                   NULL, NULL,

   868                   g_cclosure_marshal_VOID__BOXED,

   869                   G_TYPE_NONE, 1, (dbus_g_type_get_collection ("GPtrArray", (dbus_g_type_get_struct ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID)))));

   870 

   871   signals[NEW_CHANNEL] =

   872     g_signal_new ("new-channel",

   873                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   874                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   875                   0,

   876                   NULL, NULL,

   877                   gabble_connection_marshal_VOID__STRING_STRING_UINT_UINT_BOOLEAN,

   878                   G_TYPE_NONE, 5, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);

   879 

   880   signals[PRESENCE_UPDATE] =

   881     g_signal_new ("presence-update",

   882                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   883                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   884                   0,

   885                   NULL, NULL,

   886                   g_cclosure_marshal_VOID__BOXED,

   887                   G_TYPE_NONE, 1, (dbus_g_type_get_map ("GHashTable", G_TYPE_UINT, (dbus_g_type_get_struct ("GValueArray", G_TYPE_UINT, (dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, (dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE)))), G_TYPE_INVALID)))));

   888 

   889   signals[STATUS_CHANGED] =

   890     g_signal_new ("status-changed",

   891                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   892                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   893                   0,

   894                   NULL, NULL,

   895                   gabble_connection_marshal_VOID__UINT_UINT,

   896                   G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);

   897 

   898   signals[DISCONNECTED] =

   899     g_signal_new ("disconnected",

   900                   G_OBJECT_CLASS_TYPE (gabble_connection_class),

   901                   G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

   902                   0,

   903                   NULL, NULL,

   904                   g_cclosure_marshal_VOID__VOID,

   905                   G_TYPE_NONE, 0);

   906 

   907   dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_connection_class), &dbus_glib_gabble_connection_object_info);

   908 

   909   gabble_properties_mixin_class_init (G_OBJECT_CLASS (gabble_connection_class),

   910                                       G_STRUCT_OFFSET (GabbleConnectionClass, properties_class),

   911                                       connection_property_signatures, NUM_CONN_PROPS,

   912                                       NULL);

   913 }

   914 

   915 static gboolean

   916 _unref_lm_connection (gpointer data)

   917 {

   918   LmConnection *conn = (LmConnection *) data;

   919 

   920   lm_connection_unref (conn);

   921   return FALSE;

   922 }

   923 

   924 void

   925 gabble_connection_dispose (GObject *object)

   926 {

   927   GabbleConnection *self = GABBLE_CONNECTION (object);

   928   GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

   929   DBusGProxy *bus_proxy;

   930   guint i;

   931   bus_proxy = tp_get_bus_proxy ();

   932 

   933   if (priv->dispose_has_run)

   934     return;

   935 

   936   priv->dispose_has_run = TRUE;

   937 

   938   gabble_debug (DEBUG_FLAG, "called");

   939 

   940   g_message("1 Inside gabble_connection_dispose() method");

   941   

   942   //<todo> are these asserts a valid one ?

   943   //As in case of lm_connection_open these will not be valid assertions ?

   944   //to remove these?

   945   g_assert ((self->status == TP_CONN_STATUS_DISCONNECTED) ||

   946             (self->status == TP_CONN_STATUS_NEW));

   947   //This is not a valid statement as the self_handle is set to a value in _gabble_connection_connect which wil call 

   948   //lm_connection_open(within do_connect). If the call fails then control comes here.. in which case self_handle can be other 

   949   //than 0)

   950   //g_assert (self->self_handle == 0);

   951 

   952   g_message("after assert");

   953   if (priv->channel_requests)

   954     {

   955       g_assert (priv->channel_requests->len == 0);

   956       g_ptr_array_free (priv->channel_requests, TRUE);

   957       priv->channel_requests = NULL;

   958     }

   959 

   960   g_ptr_array_foreach (priv->channel_factories, (GFunc) g_object_unref, NULL);

   961   g_ptr_array_free (priv->channel_factories, TRUE);

   962   priv->channel_factories = NULL;

   963   g_message("unrefed channel factories");

   964   if(self->search_instr)

   965 	  {

   966 	    g_free( self->search_instr );

   967 	  	self->search_instr = NULL;

   968 	  }

   969 	 

   970   if(self->search_key_names)

   971 	  {

   972 	  	for( i=0; self->search_key_names[i]; i++ )

   973 			{

   974 			g_free( self->search_key_names[i] );

   975 			self->search_key_names[i] = NULL;

   976 			}

   977 	  	g_free( self->search_key_names );

   978 	  	self->search_key_names = NULL;	

   979 	  }

   980   g_message("freed search keys");

   981   if ( self->self_avatar_sha1 )

   982       {

   983       g_free ( self->self_avatar_sha1 );

   984       }

   985   if(self->search_key_ht)

   986 	  {

   987 	   g_hash_table_destroy (self->search_key_ht);

   988 	   self->search_key_ht = NULL;	

   989 	  }	  

   990   if(self->search_service_jid)

   991 	  {

   992 	   g_free(self->search_service_jid);

   993 	   self->search_service_jid = NULL;	

   994 	  }

   995   /* unreffing channel factories frees the roster */

   996   self->roster = NULL;

   997 

   998   g_object_unref (self->disco);

   999   self->disco = NULL;

  1000 

  1001   g_object_unref (self->vcard_manager);

  1002   self->vcard_manager = NULL;

  1003 

  1004   g_object_unref (self->presence_cache);

  1005   self->presence_cache = NULL;

  1006 

  1007   /* if this is not already the case, we'll crash anyway */

  1008   g_assert (!lm_connection_is_open (self->lmconn));

  1009   g_assert (priv->iq_search_keys_cb == NULL);

  1010   g_assert (priv->iq_jingle_info_cb == NULL);

  1011   g_assert (priv->iq_disco_cb == NULL);

  1012   g_assert (priv->iq_unknown_cb == NULL);

  1013   g_assert (priv->stream_error_cb == NULL);

  1014 

  1015   /*

  1016    * The Loudmouth connection can't be unref'd immediately because this

  1017    * function might (indirectly) return into Loudmouth code which expects the

  1018    * connection to always be there.

  1019    */

  1020   g_idle_add (_unref_lm_connection, self->lmconn);

  1021 

  1022   if (NULL != self->bus_name)

  1023     {

  1024       dbus_g_proxy_call_no_reply (bus_proxy, "ReleaseName",

  1025                                   G_TYPE_STRING, self->bus_name,

  1026                                   G_TYPE_INVALID);

  1027     }

  1028 

  1029   if (G_OBJECT_CLASS (gabble_connection_parent_class)->dispose)

  1030     G_OBJECT_CLASS (gabble_connection_parent_class)->dispose (object);

  1031   

  1032   g_message("out of the method");

  1033 }

  1034 

  1035 void

  1036 gabble_connection_finalize (GObject *object)

  1037 {

  1038   GabbleConnection *self = GABBLE_CONNECTION (object);

  1039   GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

  1040 

  1041   gabble_debug (DEBUG_FLAG, "called with %p", object);

  1042 

  1043   g_free (self->bus_name);

  1044   g_free (self->object_path);

  1045 

  1046   g_free (priv->protocol);

  1047   g_free (priv->connect_server);

  1048   g_free (priv->stream_server);

  1049   g_free (priv->username);

  1050   g_free (priv->password);

  1051   g_free (priv->resource);

  1052 

  1053   g_free (priv->https_proxy_server);

  1054   g_free (priv->fallback_conference_server);

  1055 

  1056   g_free (priv->alias);

  1057 

  1058   gabble_properties_mixin_finalize (object);

  1059 

  1060   gabble_handle_repo_destroy (self->handles);

  1061 

  1062   G_OBJECT_CLASS (gabble_connection_parent_class)->finalize (object);

  1063 }

  1064 

  1065 /**

  1066  * _gabble_connection_set_properties_from_account

  1067  *

  1068  * Parses an account string which may be one of the following forms:

  1069  *  username

  1070  *  username/resource

  1071  *  username@server

  1072  *  username@server/resource

  1073  * and sets the properties for username, stream server and resource

  1074  * appropriately. Also sets the connect server to the stream server if one has

  1075  * not yet been specified.

  1076  */

  1077 

  1078 gboolean

  1079 _gabble_connection_set_properties_from_account (GabbleConnection *conn,

  1080                                                 const gchar      *account,

  1081                                                 GError          **error)

  1082 {

  1083   GabbleConnectionPrivate *priv;

  1084   char *username, *server, *resource;

  1085   gboolean result;

  1086 

  1087   g_assert (GABBLE_IS_CONNECTION (conn));

  1088   g_assert (account != NULL);

  1089 

  1090   priv = GABBLE_CONNECTION_GET_PRIVATE (conn);

  1091 

  1092   username = server = resource = NULL;

  1093   result = TRUE;

  1094 

  1095   gabble_decode_jid (account, &username, &server, &resource);

  1096 

  1097   if (username == NULL || server == NULL ||

  1098       *username == '\0' || *server == '\0')

  1099     {

  1100       g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

  1101           "unable to get username and server from account");

  1102       result = FALSE;

  1103       goto OUT;

  1104     }

  1105 

  1106   g_object_set (G_OBJECT (conn),

  1107                 "username", username,

  1108                 "stream-server", server,

  1109                 NULL);

  1110 

  1111   /* only override the default resource if we actually got one */

  1112   if (resource)

  1113     g_object_set (G_OBJECT (conn), "resource", resource, NULL);

  1114 

  1115 OUT:

  1116   g_free (username);

  1117   g_free (server);

  1118   g_free (resource);

  1119 

  1120   return result;

  1121 }

  1122 

  1123 /**

  1124  * _gabble_connection_register

  1125  *

  1126  * Make the connection object appear on the bus, returning the bus

  1127  * name and object path used.

  1128  */

  1129 gboolean

  1130 _gabble_connection_register (GabbleConnection *conn,

  1131                              gchar           **bus_name,

  1132                              gchar           **object_path,

  1133                              GError          **error)

  1134 {

  1135   DBusGConnection *bus;