src: remove annoying salut- prefix

Signed-off-by: Jonny Lamb <jonny.lamb@collabora.co.uk>

1 files changed, 4111 insertions, 0 deletions

diff --git a/src/connection.c b/src/connection.c
new file mode 100644
index 00000000..75e10c95
--- /dev/null
+++ b/src/connection.c
@@ -0,0 +1,4111 @@
+/*
+ * connection.c - Source for SalutConnection
+ * Copyright (C) 2005 Collabora Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "connection.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <ctype.h>
+
+#include <dbus/dbus-protocol.h>
+#include <dbus/dbus-glib-bindings.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include <telepathy-glib/channel-manager.h>
+#include <telepathy-glib/dbus.h>
+#include <telepathy-glib/gtypes.h>
+#include <telepathy-glib/handle-repo-dynamic.h>
+#include <telepathy-glib/handle-repo.h>
+#include <telepathy-glib/handle-repo-static.h>
+#include <telepathy-glib/interfaces.h>
+#include <telepathy-glib/svc-generic.h>
+#include <telepathy-glib/util.h>
+
+#include <gibber/gibber-namespaces.h>
+
+#include <salut/caps-channel-manager.h>
+
+#include <wocky/wocky-meta-porter.h>
+#include <wocky/wocky-data-form.h>
+#include <wocky/wocky-xep-0115-capabilities.h>
+
+#include "capabilities.h"
+#include "avahi-discovery-client.h"
+#include "capabilities.h"
+#include "caps-hash.h"
+#include "contact-channel.h"
+#include "contact.h"
+#include "contact-manager.h"
+#include "disco.h"
+#include "discovery-client.h"
+#include "im-manager.h"
+#include "muc-manager.h"
+#include "ft-manager.h"
+#include "contact.h"
+#include "roomlist-manager.h"
+#include "presence.h"
+#include "presence-cache.h"
+#include "self.h"
+#include "si-bytestream-manager.h"
+#include "tubes-manager.h"
+#include "util.h"
+
+#include "plugin-loader.h"
+
+#ifdef ENABLE_OLPC
+#include "olpc-activity-manager.h"
+#endif
+
+#include <extensions/extensions.h>
+
+#define DEBUG_FLAG DEBUG_CONNECTION
+#include "debug.h"
+
+#define SALUT_TP_ALIAS_PAIR_TYPE (dbus_g_type_get_struct ("GValueArray", \
+      G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID))
+
+#ifdef ENABLE_OLPC
+
+#define ACTIVITY_PAIR_TYPE \
+  (dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_UINT, \
+      G_TYPE_INVALID))
+
+static void
+salut_connection_olpc_buddy_info_iface_init (gpointer g_iface,
+    gpointer iface_data);
+
+static void
+salut_connection_olpc_activity_properties_iface_init (gpointer g_iface,
+    gpointer iface_data);
+
+#endif
+
+static void
+salut_connection_aliasing_service_iface_init (gpointer g_iface,
+    gpointer iface_data);
+
+static void
+salut_connection_avatar_service_iface_init (gpointer g_iface,
+    gpointer iface_data);
+
+static void
+salut_conn_contact_caps_iface_init (gpointer, gpointer);
+
+static void salut_conn_future_iface_init (gpointer, gpointer);
+
+#define DISCONNECT_TIMEOUT 5
+
+G_DEFINE_TYPE_WITH_CODE(SalutConnection,
+    salut_connection,
+    TP_TYPE_BASE_CONNECTION,
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_ALIASING,
+        salut_connection_aliasing_service_iface_init);
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_PRESENCE,
+       tp_presence_mixin_iface_init);
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_DBUS_PROPERTIES,
+       tp_dbus_properties_mixin_iface_init);
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACTS,
+       tp_contacts_mixin_iface_init);
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_SIMPLE_PRESENCE,
+       tp_presence_mixin_simple_presence_iface_init);
+    G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_AVATARS,
+       salut_connection_avatar_service_iface_init);
+    G_IMPLEMENT_INTERFACE
+      (TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACT_CAPABILITIES,
+      salut_conn_contact_caps_iface_init);
+    G_IMPLEMENT_INTERFACE (SALUT_TYPE_SVC_CONNECTION_FUTURE,
+      salut_conn_future_iface_init);
+#ifdef ENABLE_OLPC
+    G_IMPLEMENT_INTERFACE (SALUT_TYPE_SVC_OLPC_BUDDY_INFO,
+       salut_connection_olpc_buddy_info_iface_init);
+    G_IMPLEMENT_INTERFACE (SALUT_TYPE_SVC_OLPC_ACTIVITY_PROPERTIES,
+       salut_connection_olpc_activity_properties_iface_init);
+#endif
+    )
+
+#ifdef ENABLE_OLPC
+static gboolean uninvite_stanza_callback (WockyPorter *porter,
+    WockyStanza *stanza, gpointer user_data);
+#endif
+
+/* properties */
+enum {
+  PROP_NICKNAME = 1,
+  PROP_FIRST_NAME,
+  PROP_LAST_NAME,
+  PROP_JID,
+  PROP_EMAIL,
+  PROP_PUBLISHED_NAME,
+  PROP_IM_MANAGER,
+  PROP_MUC_MANAGER,
+  PROP_TUBES_MANAGER,
+  PROP_ROOMLIST_MANAGER,
+  PROP_CONTACT_MANAGER,
+  PROP_SELF,
+  PROP_XCM,
+  PROP_SI_BYTESTREAM_MANAGER,
+#ifdef ENABLE_OLPC
+  PROP_OLPC_ACTIVITY_MANAGER,
+#endif
+  PROP_BACKEND,
+  PROP_DNSSD_NAME,
+  LAST_PROP
+};
+
+struct _SalutConnectionPrivate
+{
+  gboolean dispose_has_run;
+
+  /* Connection information */
+  gchar *published_name;
+  gchar *nickname;
+  gchar *first_name;
+  gchar *last_name;
+  gchar *jid;
+  gchar *email;
+#ifdef ENABLE_OLPC
+  gchar *olpc_color;
+  GArray *olpc_key;
+#endif
+
+  /* Discovery client for browsing and resolving */
+  SalutDiscoveryClient *discovery_client;
+
+  /* TpHandler for our presence on the lan */
+  SalutSelf *self;
+  gboolean self_established;
+  SalutPresenceId pre_connect_presence;
+  gchar *pre_connect_message;
+  GabbleCapabilitySet *pre_connect_caps;
+  GPtrArray *pre_connect_data_forms;
+
+  /* Contact manager */
+  SalutContactManager *contact_manager;
+
+  /* IM channel manager */
+  SalutImManager *im_manager;
+
+  /* MUC channel manager */
+  SalutMucManager *muc_manager;
+
+  /* FT channel manager */
+  SalutFtManager *ft_manager;
+
+  /* Roomlist channel manager */
+  SalutRoomlistManager *roomlist_manager;
+
+  /* Tubes channel manager */
+  SalutTubesManager *tubes_manager;
+
+  /* Bytestream manager for stream initiation (XEP-0095) */
+  SalutSiBytestreamManager *si_bytestream_manager;
+
+  /* Sidecars */
+  /* gchar *interface → SalutSidecar */
+  GHashTable *sidecars;
+
+  /* gchar *interface → GList<DBusGMethodInvocation> */
+  GHashTable *pending_sidecars;
+
+#ifdef ENABLE_OLPC
+  SalutOlpcActivityManager *olpc_activity_manager;
+  guint uninvite_handler_id;
+#endif
+
+  /* timer used when trying to properly disconnect */
+  guint disconnect_timer;
+
+  /* Backend type: avahi or dummy */
+  GType backend_type;
+
+  /* DNS-SD name, used for the avahi backend */
+  gchar *dnssd_name;
+};
+
+typedef struct _ChannelRequest ChannelRequest;
+
+struct _ChannelRequest
+{
+  DBusGMethodInvocation *context;
+  gchar *channel_type;
+  guint handle_type;
+  guint handle;
+  gboolean suppress_handler;
+};
+
+static void _salut_connection_disconnect (SalutConnection *self);
+
+static void
+salut_connection_create_handle_repos (TpBaseConnection *self,
+    TpHandleRepoIface *repos[NUM_TP_HANDLE_TYPES]);
+
+static GPtrArray *
+salut_connection_create_channel_factories (TpBaseConnection *self);
+
+static GPtrArray *
+salut_connection_create_channel_managers (TpBaseConnection *self);
+
+static gchar *
+salut_connection_get_unique_connection_name (TpBaseConnection *self);
+
+static void
+salut_connection_shut_down (TpBaseConnection *self);
+
+static gboolean
+salut_connection_start_connecting (TpBaseConnection *self, GError **error);
+
+static void salut_connection_avatars_fill_contact_attributes (GObject *obj,
+    const GArray *contacts, GHashTable *attributes_hash);
+
+static void salut_connection_aliasing_fill_contact_attributes (GObject *obj,
+    const GArray *contacts, GHashTable *attributes_hash);
+
+static void conn_contact_capabilities_fill_contact_attributes (GObject *obj,
+  const GArray *contacts, GHashTable *attributes_hash);
+
+static void connection_capabilities_update_cb (SalutPresenceCache *cache,
+    TpHandle handle, gpointer user_data);
+
+static void
+conn_avatars_properties_getter (GObject *object, GQuark interface, GQuark name,
+    GValue *value, gpointer getter_data);
+
+static const char *mimetypes[] = {
+    "image/png", "image/jpeg", NULL };
+
+#define AVATAR_MIN_PX 0
+#define AVATAR_REC_PX 64
+#define AVATAR_MAX_PX 0
+#define AVATAR_MAX_BYTES G_MAXUINT16
+
+static TpDBusPropertiesMixinPropImpl conn_avatars_properties[] = {
+      { "MinimumAvatarWidth", GUINT_TO_POINTER (AVATAR_MIN_PX), NULL },
+      { "RecommendedAvatarWidth", GUINT_TO_POINTER (AVATAR_REC_PX), NULL },
+      { "MaximumAvatarWidth", GUINT_TO_POINTER (AVATAR_MAX_PX), NULL },
+      { "MinimumAvatarHeight", GUINT_TO_POINTER (AVATAR_MIN_PX), NULL },
+      { "RecommendedAvatarHeight", GUINT_TO_POINTER (AVATAR_REC_PX), NULL },
+      { "MaximumAvatarHeight", GUINT_TO_POINTER (AVATAR_MAX_PX), NULL },
+      { "MaximumAvatarBytes", GUINT_TO_POINTER (AVATAR_MAX_BYTES), NULL },
+      /* special-cased - it's the only one with a non-guint value */
+      { "SupportedAvatarMIMETypes", NULL, NULL },
+      { NULL }
+};
+
+static void
+salut_connection_init (SalutConnection *obj)
+{
+  SalutConnectionPrivate *priv =
+    G_TYPE_INSTANCE_GET_PRIVATE(obj, SALUT_TYPE_CONNECTION,
+                                SalutConnectionPrivate);
+
+  obj->priv = priv;
+  obj->name = NULL;
+
+  gabble_capabilities_init (obj);
+
+  tp_presence_mixin_init ((GObject *) obj,
+      G_STRUCT_OFFSET (SalutConnection, presence_mixin));
+
+  /* create this now so channel managers can use it when created from
+   * parent->constructor */
+  obj->session = wocky_session_new_ll (NULL);
+  obj->porter = wocky_session_get_porter (obj->session);
+
+  /* allocate any data required by the object here */
+  priv->published_name = g_strdup (g_get_user_name ());
+  priv->nickname = NULL;
+  priv->first_name = NULL;
+  priv->last_name = NULL;
+  priv->jid = NULL;
+  priv->email = NULL;
+#ifdef ENABLE_OLPC
+  priv->olpc_color = NULL;
+  priv->olpc_key = NULL;
+#endif
+
+  priv->discovery_client = NULL;
+  priv->self = NULL;
+  priv->self_established = FALSE;
+
+  priv->pre_connect_presence = SALUT_PRESENCE_AVAILABLE;
+  priv->pre_connect_message = NULL;
+  priv->pre_connect_caps = NULL;
+
+  priv->contact_manager = NULL;
+}
+
+static void
+sidecars_conn_status_changed_cb (SalutConnection *conn,
+    guint status, guint reason, gpointer unused);
+
+static GObject *
+salut_connection_constructor (GType type,
+                              guint n_props,
+                              GObjectConstructParam *props)
+{
+  GObject *obj;
+  SalutConnection *self;
+  SalutConnectionPrivate *priv;
+
+  obj = G_OBJECT_CLASS (salut_connection_parent_class)->
+           constructor (type, n_props, props);
+  self = SALUT_CONNECTION (obj);
+  priv = self->priv;
+
+  self->disco = salut_disco_new (self);
+  self->presence_cache = salut_presence_cache_new (self);
+  g_signal_connect (self->presence_cache, "capabilities-update", G_CALLBACK
+      (connection_capabilities_update_cb), self);
+
+  tp_contacts_mixin_init (obj,
+      G_STRUCT_OFFSET (SalutConnection, contacts_mixin));
+
+  tp_base_connection_register_with_contacts_mixin (TP_BASE_CONNECTION (obj));
+  tp_presence_mixin_simple_presence_register_with_contacts_mixin (obj);
+
+  tp_contacts_mixin_add_contact_attributes_iface (obj,
+      TP_IFACE_CONNECTION_INTERFACE_AVATARS,
+      salut_connection_avatars_fill_contact_attributes);
+
+  tp_contacts_mixin_add_contact_attributes_iface (obj,
+      TP_IFACE_CONNECTION_INTERFACE_ALIASING,
+      salut_connection_aliasing_fill_contact_attributes);
+
+  tp_contacts_mixin_add_contact_attributes_iface (G_OBJECT (self),
+      TP_IFACE_CONNECTION_INTERFACE_CONTACT_CAPABILITIES,
+          conn_contact_capabilities_fill_contact_attributes);
+
+  priv->sidecars = g_hash_table_new_full (g_str_hash, g_str_equal,
+      g_free, g_object_unref);
+  priv->pending_sidecars = g_hash_table_new_full (g_str_hash, g_str_equal,
+      g_free, (GDestroyNotify) g_list_free);
+
+  g_signal_connect (self, "status-changed",
+      (GCallback) sidecars_conn_status_changed_cb, NULL);
+
+  return obj;
+}
+
+static void
+salut_connection_get_property (GObject *object,
+                               guint property_id,
+                               GValue *value,
+                               GParamSpec *pspec)
+{
+  SalutConnection *self = SALUT_CONNECTION(object);
+  SalutConnectionPrivate *priv = self->priv;
+
+  switch (property_id)
+    {
+    case PROP_NICKNAME:
+      g_value_set_string (value, priv->nickname);
+      break;
+    case PROP_FIRST_NAME:
+      g_value_set_string (value, priv->first_name);
+      break;
+    case PROP_LAST_NAME:
+      g_value_set_string (value, priv->last_name);
+      break;
+    case PROP_JID:
+      g_value_set_string (value, priv->jid);
+      break;
+    case PROP_EMAIL:
+      g_value_set_string (value, priv->email);
+      break;
+    case PROP_PUBLISHED_NAME:
+      g_value_set_string (value, priv->published_name);
+      break;
+    case PROP_IM_MANAGER:
+      g_value_set_object (value, priv->im_manager);
+      break;
+    case PROP_MUC_MANAGER:
+      g_value_set_object (value, priv->muc_manager);
+      break;
+    case PROP_TUBES_MANAGER:
+      g_value_set_object (value, priv->tubes_manager);
+      break;
+    case PROP_ROOMLIST_MANAGER:
+      g_value_set_object (value, priv->roomlist_manager);
+      break;
+    case PROP_CONTACT_MANAGER:
+      g_value_set_object (value, priv->contact_manager);
+      break;
+    case PROP_SELF:
+      g_value_set_object (value, priv->self);
+      break;
+    case PROP_SI_BYTESTREAM_MANAGER:
+      g_value_set_object (value, priv->si_bytestream_manager);
+      break;
+#ifdef ENABLE_OLPC
+    case PROP_OLPC_ACTIVITY_MANAGER:
+      g_value_set_object (value, priv->olpc_activity_manager);
+      break;
+#endif
+    case PROP_BACKEND:
+      g_value_set_gtype (value, priv->backend_type);
+      break;
+    case PROP_DNSSD_NAME:
+      g_value_set_string (value, priv->dnssd_name);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+salut_connection_set_property (GObject *object,
+                               guint property_id,
+                               const GValue *value,
+                               GParamSpec *pspec)
+{
+  SalutConnection *self = SALUT_CONNECTION(object);
+  SalutConnectionPrivate *priv = self->priv;
+
+  switch (property_id)
+    {
+    case PROP_NICKNAME:
+      g_free (priv->nickname);
+      priv->nickname = g_value_dup_string (value);
+      break;
+    case PROP_FIRST_NAME:
+      g_free (priv->first_name);
+      priv->first_name = g_value_dup_string (value);
+      break;
+    case PROP_LAST_NAME:
+      g_free (priv->last_name);
+      priv->last_name = g_value_dup_string (value);
+      break;
+    case PROP_JID:
+      g_free (priv->jid);
+      priv->jid = g_value_dup_string (value);
+      break;
+    case PROP_EMAIL:
+      g_free (priv->email);
+      priv->email = g_value_dup_string (value);
+      break;
+    case PROP_PUBLISHED_NAME:
+      g_free (priv->published_name);
+      priv->published_name = g_value_dup_string (value);
+      break;
+    case PROP_BACKEND:
+      priv->backend_type = g_value_get_gtype (value);
+      /* Create the backend object */
+      priv->discovery_client = g_object_new (priv->backend_type,
+          "dnssd-name", priv->dnssd_name,
+          NULL);
+      g_assert (priv->discovery_client != NULL);
+      break;
+    case PROP_DNSSD_NAME:
+      priv->dnssd_name = g_value_dup_string (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+
+static void salut_connection_dispose (GObject *object);
+static void salut_connection_finalize (GObject *object);
+
+/* presence bits and pieces */
+
+static const TpPresenceStatusOptionalArgumentSpec presence_args[] = {
+      { "message", "s" },
+      { NULL }
+};
+
+/* keep these in the same order as SalutPresenceId... */
+static const TpPresenceStatusSpec presence_statuses[] = {
+      { "available", TP_CONNECTION_PRESENCE_TYPE_AVAILABLE, TRUE,
+        presence_args },
+      { "away", TP_CONNECTION_PRESENCE_TYPE_AWAY, TRUE, presence_args },
+      { "dnd", TP_CONNECTION_PRESENCE_TYPE_BUSY, TRUE, presence_args },
+      { "offline", TP_CONNECTION_PRESENCE_TYPE_OFFLINE, FALSE, NULL },
+      { NULL }
+};
+/* ... and these too (declared in presence.h) */
+const char *salut_presence_status_txt_names[] = {
+  "avail",
+  "away",
+  "dnd",
+  "offline",
+  NULL
+};
+
+static gboolean
+is_presence_status_available (GObject *obj,
+                              guint index_)
+{
+  return (index_ < SALUT_PRESENCE_OFFLINE);
+}
+
+static GHashTable *
+make_presence_opt_args (SalutPresenceId presence, const gchar *message)
+{
+  GHashTable *ret;
+  GValue *value;
+
+  /* Omit missing or empty messages from the hash table.
+   * Also, offline has no message in Salut, it wouldn't make sense. */
+  if (presence == SALUT_PRESENCE_OFFLINE || message == NULL ||
+      *message == '\0')
+    {
+      return NULL;
+    }
+
+  ret = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
+      (GDestroyNotify) tp_g_value_slice_free);
+
+  value = g_slice_new0 (GValue);
+  g_value_init (value, G_TYPE_STRING);
+  g_value_set_string (value, message);
+  g_hash_table_insert (ret, "message", value);
+
+  return ret;
+}
+
+static GHashTable *
+get_contact_statuses (GObject *obj,
+                      const GArray *handles,
+                      GError **error)
+{
+  SalutConnection *self = SALUT_CONNECTION (obj);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  TpHandleRepoIface *handle_repo = tp_base_connection_get_handles (base,
+    TP_HANDLE_TYPE_CONTACT);
+  GHashTable *ret;
+  guint i;
+
+  if (!tp_handles_are_valid (handle_repo, handles, FALSE, error))
+    {
+      return NULL;
+    }
+
+  ret = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+      NULL, (GDestroyNotify) tp_presence_status_free);
+
+  for (i = 0; i < handles->len; i++)
+    {
+      TpHandle handle = g_array_index (handles, TpHandle, i);
+      TpPresenceStatus *ps = tp_presence_status_new
+          (SALUT_PRESENCE_OFFLINE, NULL);
+      const gchar *message = NULL;
+
+      if (handle == base->self_handle)
+        {
+          ps->index = priv->self->status;
+          message = priv->self->status_message;
+        }
+      else
+        {
+          SalutContact *contact = salut_contact_manager_get_contact
+              (priv->contact_manager, handle);
+
+          if (contact != NULL)
+            {
+              ps->index = contact->status;
+              message = contact->status_message;
+              g_object_unref (contact);
+            }
+        }
+
+      ps->optional_arguments = make_presence_opt_args (ps->index, message);
+
+      g_hash_table_insert (ret, GUINT_TO_POINTER (handle), ps);
+    }
+
+  return ret;
+}
+
+static void
+set_self_presence (SalutConnection *self,
+    SalutPresenceId presence,
+    const gchar *message,
+    GError **error)
+{
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+
+  if (priv->self == NULL || !priv->self_established)
+    {
+      g_free (priv->pre_connect_message);
+      priv->pre_connect_presence = presence;
+      priv->pre_connect_message = g_strdup (message);
+      return;
+    }
+
+  if (salut_self_set_presence (priv->self, presence, message, error))
+    {
+      TpPresenceStatus ps = { priv->self->status,
+          make_presence_opt_args (priv->self->status,
+              priv->self->status_message) };
+
+      tp_presence_mixin_emit_one_presence_update ((GObject *) self,
+          base->self_handle, &ps);
+
+      if (ps.optional_arguments != NULL)
+        g_hash_table_destroy (ps.optional_arguments);
+    }
+}
+
+static gboolean
+set_own_status (GObject *obj,
+                const TpPresenceStatus *status,
+                GError **error)
+{
+  SalutConnection *self = SALUT_CONNECTION (obj);
+  GError *err = NULL;
+  const GValue *value;
+  const gchar *message = NULL;
+  SalutPresenceId presence = SALUT_PRESENCE_AVAILABLE;
+
+  if (status != NULL)
+    {
+      /* mixin has already validated the index */
+      presence = status->index;
+
+      if (status->optional_arguments != NULL)
+        {
+          value = g_hash_table_lookup (status->optional_arguments, "message");
+          if (value)
+            {
+              /* TpPresenceMixin should validate this for us, but doesn't */
+              if (!G_VALUE_HOLDS_STRING (value))
+                {
+                  g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+                      "Status argument 'message' requires a string");
+                  return FALSE;
+                }
+              message = g_value_get_string (value);
+            }
+        }
+    }
+
+  set_self_presence (self, presence, message, &err);
+
+  if (err != NULL)
+    {
+      *error = g_error_new_literal (TP_ERRORS, TP_ERROR_NETWORK_ERROR,
+          err->message);
+    }
+
+  return TRUE;
+}
+
+static const gchar *interfaces [] = {
+  TP_IFACE_CONNECTION_INTERFACE_ALIASING,
+  TP_IFACE_CONNECTION_INTERFACE_AVATARS,
+  TP_IFACE_CONNECTION_INTERFACE_CONTACTS,
+  TP_IFACE_CONNECTION_INTERFACE_PRESENCE,
+  TP_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE,
+  TP_IFACE_CONNECTION_INTERFACE_REQUESTS,
+  TP_IFACE_CONNECTION_INTERFACE_CONTACT_CAPABILITIES,
+  SALUT_IFACE_CONNECTION_FUTURE,
+#ifdef ENABLE_OLPC
+  SALUT_IFACE_OLPC_BUDDY_INFO,
+  SALUT_IFACE_OLPC_ACTIVITY_PROPERTIES,
+#endif
+  NULL };
+
+const gchar * const *
+salut_connection_get_implemented_interfaces (void)
+{
+  return interfaces;
+}
+
+static void
+salut_connection_class_init (SalutConnectionClass *salut_connection_class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (salut_connection_class);
+  TpBaseConnectionClass *tp_connection_class =
+      TP_BASE_CONNECTION_CLASS(salut_connection_class);
+  GParamSpec *param_spec;
+  static TpDBusPropertiesMixinIfaceImpl prop_interfaces[] = {
+        { TP_IFACE_CONNECTION_INTERFACE_AVATARS,
+          conn_avatars_properties_getter,
+          NULL,
+          conn_avatars_properties,
+        },
+        { NULL }
+  };
+
+  object_class->get_property = salut_connection_get_property;
+  object_class->set_property = salut_connection_set_property;
+
+  g_type_class_add_private (salut_connection_class,
+      sizeof (SalutConnectionPrivate));
+
+  object_class->constructor = salut_connection_constructor;
+
+  object_class->dispose = salut_connection_dispose;
+  object_class->finalize = salut_connection_finalize;
+
+  tp_connection_class->create_handle_repos =
+      salut_connection_create_handle_repos;
+  tp_connection_class->create_channel_factories =
+      salut_connection_create_channel_factories;
+  tp_connection_class->create_channel_managers =
+      salut_connection_create_channel_managers;
+  tp_connection_class->get_unique_connection_name =
+      salut_connection_get_unique_connection_name;
+  tp_connection_class->shut_down =
+      salut_connection_shut_down;
+  tp_connection_class->start_connecting =
+      salut_connection_start_connecting;
+  tp_connection_class->interfaces_always_present = interfaces;
+
+  salut_connection_class->properties_mixin.interfaces = prop_interfaces;
+  tp_dbus_properties_mixin_class_init (object_class,
+      G_STRUCT_OFFSET (SalutConnectionClass, properties_mixin));
+
+  tp_presence_mixin_class_init (object_class,
+      G_STRUCT_OFFSET (SalutConnectionClass, presence_mixin),
+      is_presence_status_available, get_contact_statuses, set_own_status,
+      presence_statuses);
+
+  tp_presence_mixin_simple_presence_init_dbus_properties (object_class);
+
+  tp_contacts_mixin_class_init (object_class,
+        G_STRUCT_OFFSET (SalutConnectionClass, contacts_mixin));
+
+  param_spec = g_param_spec_string ("nickname", "nickname",
+      "Nickname used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_NICKNAME, param_spec);
+
+  param_spec = g_param_spec_string ("first-name", "First name",
+      "First name used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_FIRST_NAME, param_spec);
+
+  param_spec = g_param_spec_string ("last-name", "Last name",
+      "Last name used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_LAST_NAME, param_spec);
+
+  param_spec = g_param_spec_string ("email", "E-mail address",
+      "E-mail address used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_EMAIL, param_spec);
+
+  param_spec = g_param_spec_string ("jid", "Jabber id",
+      "Jabber id used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_JID, param_spec);
+
+  param_spec = g_param_spec_string ("published-name", "Published name",
+      "Username used in the published data", NULL,
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_PUBLISHED_NAME,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "im-manager",
+      "SalutImManager object",
+      "The Salut IM Manager associated with this Salut Connection",
+      SALUT_TYPE_IM_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_IM_MANAGER,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "muc-manager",
+      "SalutMucManager object",
+      "The Salut MUC Manager associated with this Salut Connection",
+      SALUT_TYPE_MUC_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_MUC_MANAGER,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "tubes-manager",
+      "SalutTubesManager object",
+      "The Salut Tubes Manager associated with this Salut Connection",
+      SALUT_TYPE_TUBES_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_TUBES_MANAGER,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "roomlist-manager",
+      "SalutRoomlistManager object",
+      "The Salut Roomlist Manager associated with this Salut Connection",
+      SALUT_TYPE_ROOMLIST_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_ROOMLIST_MANAGER,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "contact-manager",
+      "SalutContactManager object",
+      "The Salut Contact Manager associated with this Salut Connection",
+      SALUT_TYPE_CONTACT_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_CONTACT_MANAGER,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "self",
+      "SalutSelf object",
+      "The Salut Self object associated with this Salut Connection",
+      SALUT_TYPE_SELF,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_SELF,
+      param_spec);
+
+  param_spec = g_param_spec_object (
+      "si-bytestream-manager",
+      "SalutSiBytestreamManager object",
+      "The Salut SI Bytestream Manager associated with this Salut Connection",
+      SALUT_TYPE_SI_BYTESTREAM_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_SI_BYTESTREAM_MANAGER,
+      param_spec);
+
+#ifdef ENABLE_OLPC
+  param_spec = g_param_spec_object (
+      "olpc-activity-manager",
+      "SalutOlpcActivityManager object",
+      "The OLPC activity Manager associated with this Salut Connection",
+      SALUT_TYPE_OLPC_ACTIVITY_MANAGER,
+      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_OLPC_ACTIVITY_MANAGER,
+      param_spec);
+#endif
+
+  param_spec = g_param_spec_gtype (
+      "backend-type",
+      "backend type",
+      "a G_TYPE_GTYPE of the backend to use",
+      G_TYPE_NONE,
+      G_PARAM_CONSTRUCT_ONLY |
+      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_BACKEND,
+      param_spec);
+
+  param_spec = g_param_spec_string ("dnssd-name", "DNS-SD name",
+      "The DNS-SD name of the protocol", "",
+      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_DNSSD_NAME,
+      param_spec);
+}
+
+void
+salut_connection_dispose (GObject *object)
+{
+  SalutConnection *self = SALUT_CONNECTION (object);
+  SalutConnectionPrivate *priv = self->priv;
+
+  if (priv->dispose_has_run)
+    return;
+
+  priv->dispose_has_run = TRUE;
+
+  if (self->disco != NULL)
+    {
+      g_object_unref (self->disco);
+      self->disco = NULL;
+    }
+
+  if (self->presence_cache)
+    {
+      g_object_unref (self->presence_cache);
+      self->presence_cache = NULL;
+    }
+
+  if (priv->pre_connect_message != NULL)
+    {
+      g_free (priv->pre_connect_message);
+      priv->pre_connect_message = NULL;
+    }
+
+  if (priv->pre_connect_caps != NULL)
+    {
+      gabble_capability_set_free (priv->pre_connect_caps);
+      priv->pre_connect_caps = NULL;
+    }
+
+  if (priv->pre_connect_data_forms != NULL)
+    {
+      g_ptr_array_unref (priv->pre_connect_data_forms);
+      priv->pre_connect_data_forms = NULL;
+    }
+
+  if (priv->self)
+    {
+      g_object_unref (priv->self);
+      priv->self = NULL;
+    }
+
+#ifdef ENABLE_OLPC
+  {
+    wocky_porter_unregister_handler (self->porter, priv->uninvite_handler_id);
+    priv->uninvite_handler_id = 0;
+  }
+
+  if (priv->olpc_activity_manager != NULL)
+    {
+      g_object_unref (priv->olpc_activity_manager);
+      priv->olpc_activity_manager = NULL;
+    }
+#endif
+
+  if (self->session != NULL)
+    {
+      g_object_unref (self->session);
+      self->session = NULL;
+      self->porter = NULL;
+    }
+
+  if (priv->discovery_client != NULL)
+    {
+      g_object_unref (priv->discovery_client);
+      g_signal_handlers_disconnect_matched (priv->discovery_client,
+          G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+      priv->discovery_client = NULL;
+    }
+
+  if (priv->si_bytestream_manager != NULL)
+    {
+      g_object_unref (priv->si_bytestream_manager);
+      priv->si_bytestream_manager = NULL;
+    }
+
+  g_warn_if_fail (g_hash_table_size (priv->sidecars) == 0);
+  tp_clear_pointer (&priv->sidecars, g_hash_table_unref);
+
+  g_warn_if_fail (g_hash_table_size (priv->pending_sidecars) == 0);
+  tp_clear_pointer (&priv->pending_sidecars, g_hash_table_unref);
+
+  /* release any references held by the object here */
+  if (G_OBJECT_CLASS (salut_connection_parent_class)->dispose)
+    G_OBJECT_CLASS (salut_connection_parent_class)->dispose (object);
+}
+
+void
+salut_connection_finalize (GObject *object)
+{
+  SalutConnection *self = SALUT_CONNECTION (object);
+  SalutConnectionPrivate *priv = self->priv;
+
+  /* free any data held directly by the object here */
+  tp_presence_mixin_finalize (object);
+  g_free (self->name);
+  g_free (priv->published_name);
+  g_free (priv->first_name);
+  g_free (priv->last_name);
+  g_free (priv->email);
+  g_free (priv->jid);
+#ifdef ENABLE_OLPC
+  if (priv->olpc_key != NULL)
+    g_array_free (priv->olpc_key, TRUE);
+  g_free (priv->olpc_color);
+#endif
+  g_free (priv->dnssd_name);
+
+  tp_contacts_mixin_finalize (G_OBJECT(self));
+
+  gabble_capabilities_finalize (self);
+
+  DEBUG("Finalizing connection");
+
+  G_OBJECT_CLASS (salut_connection_parent_class)->finalize (object);
+}
+
+static void
+_contact_manager_contact_status_changed (SalutConnection *self,
+    SalutContact *contact, TpHandle handle)
+{
+  TpPresenceStatus ps = { contact->status,
+    make_presence_opt_args (contact->status, contact->status_message) };
+
+  tp_presence_mixin_emit_one_presence_update ((GObject *) self, handle,
+      &ps);
+
+  if (ps.optional_arguments != NULL)
+    g_hash_table_destroy (ps.optional_arguments);
+}
+
+static gboolean
+announce_self_caps (SalutConnection *self,
+                    GError **error)
+{
+  SalutConnectionPrivate *priv = self->priv;
+  gchar *caps_hash;
+  gboolean ret;
+
+  caps_hash = caps_hash_compute_from_self_presence (priv->self);
+
+  ret = salut_self_set_caps (priv->self, GIBBER_TELEPATHY_NS_CAPS, "sha-1",
+        caps_hash, error);
+
+  if (ret)
+    {
+      salut_presence_cache_learn_caps (self->presence_cache,
+          GIBBER_TELEPATHY_NS_CAPS, caps_hash, salut_self_get_caps (priv->self),
+          wocky_xep_0115_capabilities_get_data_forms (WOCKY_XEP_0115_CAPABILITIES (priv->self)));
+    }
+
+  g_free (caps_hash);
+  return ret;
+}
+
+static void
+_self_established_cb (SalutSelf *s, gpointer data)
+{
+  SalutConnection *self = SALUT_CONNECTION (data);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *handle_repo = tp_base_connection_get_handles (
+      TP_BASE_CONNECTION (self), TP_HANDLE_TYPE_CONTACT);
+  GError *error = NULL;
+
+  priv->self_established = TRUE;
+
+  g_free (self->name);
+  self->name = g_strdup (s->name);
+
+  base->self_handle = tp_handle_ensure (handle_repo, self->name, NULL, NULL);
+
+  wocky_session_set_jid (self->session, self->name);
+
+  set_self_presence (self, priv->pre_connect_presence,
+      priv->pre_connect_message, &error);
+
+  if (error != NULL)
+    {
+      DEBUG ("Failed to set presence from pre-connection: %s", error->message);
+      g_clear_error (&error);
+    }
+
+  g_free (priv->pre_connect_message);
+  priv->pre_connect_message = NULL;
+
+  if (!salut_contact_manager_start (priv->contact_manager, &error))
+    {
+      DEBUG ("failed to start contact manager: %s", error->message);
+      g_clear_error (&error);
+
+      tp_base_connection_change_status ( TP_BASE_CONNECTION (base),
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+      return;
+  }
+
+  if (!salut_roomlist_manager_start (priv->roomlist_manager, &error))
+    {
+      DEBUG ("failed to start roomlist manager: %s", error->message);
+      g_clear_error (&error);
+
+      tp_base_connection_change_status ( TP_BASE_CONNECTION (base),
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+      return;
+    }
+
+#ifdef ENABLE_OLPC
+  if (!salut_olpc_activity_manager_start (priv->olpc_activity_manager, &error))
+    {
+      DEBUG ("failed to start olpc activity manager: %s", error->message);
+      g_clear_error (&error);
+
+      tp_base_connection_change_status ( TP_BASE_CONNECTION (base),
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+      return;
+    }
+#endif
+
+  tp_base_connection_change_status (base, TP_CONNECTION_STATUS_CONNECTED,
+      TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED);
+}
+
+
+static void
+_self_failed_cb (SalutSelf *s, GError *error, gpointer data)
+{
+  SalutConnection *self = SALUT_CONNECTION (data);
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+
+  /* FIXME better error handling */
+  tp_base_connection_change_status (base, TP_CONNECTION_STATUS_DISCONNECTED,
+     TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED);
+}
+
+static void
+discovery_client_running (SalutConnection *self)
+{
+  SalutConnectionPrivate *priv = self->priv;
+  GError *error = NULL;
+  guint16 port;
+
+  priv->self = salut_discovery_client_create_self (priv->discovery_client,
+      self, priv->nickname, priv->first_name, priv->last_name, priv->jid,
+      priv->email, priv->published_name,
+#ifdef ENABLE_OLPC
+      priv->olpc_key, priv->olpc_color
+#else
+      NULL, NULL
+#endif
+      );
+
+  if (priv->pre_connect_caps != NULL)
+    {
+      salut_self_take_caps (priv->self, priv->pre_connect_caps);
+      priv->pre_connect_caps = NULL;
+    }
+
+  if (priv->pre_connect_data_forms != NULL)
+    {
+      salut_self_take_data_forms (priv->self, priv->pre_connect_data_forms);
+      priv->pre_connect_data_forms = NULL;
+    }
+
+  g_signal_connect (priv->self, "established",
+                    G_CALLBACK(_self_established_cb), self);
+  g_signal_connect (priv->self, "failure",
+                    G_CALLBACK(_self_failed_cb), self);
+
+  wocky_session_start (self->session);
+
+  port = wocky_meta_porter_get_port (WOCKY_META_PORTER (self->porter));
+
+  if (!announce_self_caps (self, &error))
+    {
+      DEBUG ("Can't announce our capabilities: %s", error->message);
+      g_error_free (error);
+    }
+
+  if (port == 0 || !salut_self_announce (priv->self, port, &error))
+    {
+      DEBUG ("failed to announce: %s",
+          error != NULL ? error->message : "(no error message)");
+
+      tp_base_connection_change_status (
+            TP_BASE_CONNECTION (self),
+            TP_CONNECTION_STATUS_DISCONNECTED,
+            TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+
+      g_clear_error (&error);
+      return;
+    }
+
+  /* Create the bytestream manager */
+  priv->si_bytestream_manager = salut_si_bytestream_manager_new (self,
+    salut_discovery_client_get_host_name_fqdn (priv->discovery_client));
+}
+
+static void
+_discovery_client_state_changed_cb (SalutDiscoveryClient *client,
+                                    SalutDiscoveryClientState state,
+                                    SalutConnection *self)
+{
+  SalutConnectionPrivate *priv = self->priv;
+
+  g_assert (client == priv->discovery_client);
+
+  if (state == SALUT_DISCOVERY_CLIENT_STATE_CONNECTED)
+    {
+      discovery_client_running (self);
+    }
+  else if (state == SALUT_DISCOVERY_CLIENT_STATE_DISCONNECTED)
+    {
+      /* FIXME better error messages */
+      /* FIXME instead of full disconnect we could handle the avahi restart */
+      DEBUG ("discovery client got disconnected");
+      tp_base_connection_change_status (TP_BASE_CONNECTION (self),
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+    }
+}
+/* public functions */
+static void
+_salut_connection_disconnect (SalutConnection *self)
+{
+  SalutConnectionPrivate *priv = self->priv;
+
+  if (priv->self)
+    {
+      g_object_unref (priv->self);
+      priv->self = NULL;
+    }
+
+  if (priv->discovery_client != NULL)
+    {
+      g_object_unref (priv->discovery_client);
+      g_signal_handlers_disconnect_matched (priv->discovery_client,
+          G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+      priv->discovery_client = NULL;
+    }
+}
+
+
+/* Aliasing interface */
+/**
+ * salut_connection_get_alias_flags
+ *
+ * Implements D-Bus method GetAliasFlags
+ * on interface org.freedesktop.Telepathy.Connection.Interface.Aliasing
+ *
+ */
+static void
+salut_connection_get_alias_flags (TpSvcConnectionInterfaceAliasing *self,
+    DBusGMethodInvocation *context)
+{
+  /* Aliases are set by the contacts
+   * Actually we concat the first and lastname property */
+
+  tp_svc_connection_interface_aliasing_return_from_get_alias_flags (context,
+      0);
+}
+
+static const gchar *
+salut_connection_get_alias (SalutConnection *self, TpHandle handle)
+{
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (base,
+    TP_HANDLE_TYPE_CONTACT);
+  const gchar *alias;
+
+  if (handle == base->self_handle)
+    {
+      alias = salut_self_get_alias (priv->self);
+    }
+  else
+    {
+      SalutContact *contact;
+      contact = salut_contact_manager_get_contact (priv->contact_manager,
+        handle);
+
+      if (contact == NULL)
+        {
+          alias = tp_handle_inspect (contact_repo, handle);
+        }
+      else
+        {
+          alias = salut_contact_get_alias (contact);
+          g_object_unref (contact);
+        }
+    }
+
+  return alias;
+}
+
+/**
+ * salut_connection_request_aliases
+ *
+ * Implements D-Bus method RequestAliases
+ * on interface org.freedesktop.Telepathy.Connection.Interface.Aliasing
+ *
+ */
+static void
+salut_connection_request_aliases (TpSvcConnectionInterfaceAliasing *iface,
+    const GArray *contacts, DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  guint i;
+  const gchar **aliases;
+  GError *error = NULL;
+  TpHandleRepoIface *contact_handles =
+      tp_base_connection_get_handles (base, TP_HANDLE_TYPE_CONTACT);
+
+  DEBUG ("Alias requested");
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!tp_handles_are_valid (contact_handles, contacts, FALSE, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+
+  aliases = g_new0 (const gchar *, contacts->len + 1);
+  for (i = 0; i < contacts->len; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+
+      aliases[i] = salut_connection_get_alias (self, handle);
+    }
+
+  tp_svc_connection_interface_aliasing_return_from_request_aliases (context,
+    aliases);
+
+  g_free (aliases);
+  return;
+}
+
+static void
+salut_connection_get_aliases (TpSvcConnectionInterfaceAliasing *iface,
+    const GArray *contacts, DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (base,
+    TP_HANDLE_TYPE_CONTACT);
+  guint i;
+  GError *error = NULL;
+  GHashTable *result = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+    NULL, NULL);
+
+  if (!tp_handles_are_valid (contact_repo, contacts, FALSE, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+
+  for (i = 0; i < contacts->len; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+
+      g_hash_table_insert (result, GUINT_TO_POINTER (handle),
+        (gchar *) salut_connection_get_alias (self, handle));
+    }
+
+   tp_svc_connection_interface_aliasing_return_from_get_aliases (context,
+       result);
+
+   g_hash_table_destroy (result);
+}
+
+static void
+salut_connection_aliasing_fill_contact_attributes (GObject *obj,
+    const GArray *contacts, GHashTable *attributes_hash)
+{
+  SalutConnection *self = SALUT_CONNECTION (obj);
+  guint i;
+
+  for (i = 0; i < contacts->len; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+      GValue *val = tp_g_value_slice_new (G_TYPE_STRING);
+
+      g_value_set_string (val, salut_connection_get_alias (self, handle));
+
+      tp_contacts_mixin_set_contact_attribute (attributes_hash, handle,
+         TP_IFACE_CONNECTION_INTERFACE_ALIASING"/alias", val);
+    }
+}
+
+/**
+ * salut_connection_get_handle_contact_capabilities
+ *
+ * Add capabilities of handle to the given GPtrArray
+ */
+static void
+salut_connection_get_handle_contact_capabilities (SalutConnection *self,
+  TpHandle handle, GPtrArray *arr)
+{
+  TpBaseConnection *base_conn = TP_BASE_CONNECTION (self);
+  TpChannelManagerIter iter;
+  TpChannelManager *manager;
+  const GabbleCapabilitySet *set;
+  SalutContact *contact = NULL;
+
+  if (handle == base_conn->self_handle)
+    {
+      if (self->priv->self == NULL)
+        return;
+
+      set = salut_self_get_caps (self->priv->self);
+    }
+  else
+    {
+      contact = salut_contact_manager_get_contact (
+          self->priv->contact_manager, handle);
+
+      if (contact == NULL)
+        return;
+
+      set = contact->caps;
+    }
+
+  tp_base_connection_channel_manager_iter_init (&iter, base_conn);
+
+  while (tp_base_connection_channel_manager_iter_next (&iter, &manager))
+    {
+      /* all channel managers must implement the capability interface */
+      g_assert (GABBLE_IS_CAPS_CHANNEL_MANAGER (manager));
+
+      gabble_caps_channel_manager_get_contact_capabilities (
+          GABBLE_CAPS_CHANNEL_MANAGER (manager), handle, set, arr);
+    }
+
+  tp_clear_object (&contact);
+}
+
+static void
+conn_contact_capabilities_fill_contact_attributes (GObject *obj,
+  const GArray *contacts, GHashTable *attributes_hash)
+{
+  SalutConnection *self = SALUT_CONNECTION (obj);
+  guint i;
+  GPtrArray *array = NULL;
+
+  for (i = 0; i < contacts->len; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+
+      if (array == NULL)
+        array = g_ptr_array_new ();
+
+      salut_connection_get_handle_contact_capabilities (self, handle, array);
+
+      if (array->len > 0)
+        {
+          GValue *val =  tp_g_value_slice_new (
+            TP_ARRAY_TYPE_REQUESTABLE_CHANNEL_CLASS_LIST);
+
+          g_value_take_boxed (val, array);
+          tp_contacts_mixin_set_contact_attribute (attributes_hash,
+              handle,
+              TP_IFACE_CONNECTION_INTERFACE_CONTACT_CAPABILITIES"/capabilities",
+              val);
+
+          array = NULL;
+        }
+    }
+
+    if (array != NULL)
+      g_ptr_array_free (array, TRUE);
+}
+
+static void
+salut_connection_set_aliases (TpSvcConnectionInterfaceAliasing *iface,
+    GHashTable *aliases, DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  SalutConnectionPrivate *priv = self->priv;
+  GError *error = NULL;
+  const gchar *alias = g_hash_table_lookup (aliases,
+      GUINT_TO_POINTER (base->self_handle));
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (alias == NULL || g_hash_table_size (aliases) != 1)
+    {
+      GError e = { TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
+                   "In Salut you can only set your own alias" };
+
+      dbus_g_method_return_error (context, &e);
+      return;
+    }
+
+  DEBUG("Setting my alias to: %s", alias);
+
+  if (!salut_self_set_alias (priv->self, alias, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+  tp_svc_connection_interface_aliasing_return_from_set_aliases (context);
+}
+
+static void
+_contact_manager_contact_alias_changed  (SalutConnection *self,
+    SalutContact *contact, TpHandle handle)
+{
+  GPtrArray *aliases;
+  GValue entry = {0, };
+
+  g_value_init (&entry, SALUT_TP_ALIAS_PAIR_TYPE);
+  g_value_take_boxed (&entry,
+      dbus_g_type_specialized_construct (SALUT_TP_ALIAS_PAIR_TYPE));
+
+  dbus_g_type_struct_set (&entry,
+      0, handle, 1, salut_contact_get_alias (contact), G_MAXUINT);
+  aliases = g_ptr_array_sized_new (1);
+  g_ptr_array_add (aliases, g_value_get_boxed (&entry));
+
+  DEBUG("Emitting AliasesChanged");
+
+  tp_svc_connection_interface_aliasing_emit_aliases_changed (self, aliases);
+
+  g_value_unset (&entry);
+  g_ptr_array_free (aliases, TRUE);
+}
+
+static void
+salut_connection_aliasing_service_iface_init (gpointer g_iface,
+    gpointer iface_data)
+{
+  TpSvcConnectionInterfaceAliasingClass *klass =
+    (TpSvcConnectionInterfaceAliasingClass *) g_iface;
+
+#define IMPLEMENT(x) tp_svc_connection_interface_aliasing_implement_##x \
+    (klass, salut_connection_##x)
+  IMPLEMENT (get_alias_flags);
+  IMPLEMENT (request_aliases);
+  IMPLEMENT (get_aliases);
+  IMPLEMENT (set_aliases);
+#undef IMPLEMENT
+}
+
+/* Avatar service implementation */
+static void
+_contact_manager_contact_avatar_changed (SalutConnection *self,
+    SalutContact *contact, TpHandle handle)
+{
+  tp_svc_connection_interface_avatars_emit_avatar_updated (self,
+      (guint)handle, contact->avatar_token);
+}
+
+static void
+salut_connection_clear_avatar (TpSvcConnectionInterfaceAvatars *iface,
+    DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  GError *error = NULL;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!salut_self_set_avatar (priv->self, NULL, 0, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+  tp_svc_connection_interface_avatars_return_from_clear_avatar (context);
+}
+
+static void
+salut_connection_set_avatar (TpSvcConnectionInterfaceAvatars *iface,
+    const GArray *avatar, const gchar *mime_type,
+    DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  GError *error = NULL;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!salut_self_set_avatar (priv->self, (guint8 *) avatar->data,
+        avatar->len, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+
+  tp_svc_connection_interface_avatars_emit_avatar_updated (self,
+      base->self_handle, priv->self->avatar_token);
+  tp_svc_connection_interface_avatars_return_from_set_avatar (context,
+      priv->self->avatar_token);
+}
+
+
+static void
+salut_connection_get_avatar_tokens (TpSvcConnectionInterfaceAvatars *iface,
+    const GArray *contacts, DBusGMethodInvocation *context)
+{
+  guint i;
+  gchar **ret;
+  GError *err = NULL;
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *handle_repo;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  handle_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_CONTACT);
+
+  if (!tp_handles_are_valid (handle_repo, contacts, FALSE, &err))
+    {
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      return;
+    }
+
+  ret = g_new0(gchar *, contacts->len + 1);
+
+  for (i = 0; i < contacts->len ; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+      if (base->self_handle == handle)
+        {
+          ret[i] = priv->self->avatar_token;
+        }
+      else
+        {
+           SalutContact *contact;
+
+           contact = salut_contact_manager_get_contact (priv->contact_manager,
+               handle);
+           if (contact != NULL)
+             {
+               ret[i] = contact->avatar_token;
+               g_object_unref (contact);
+             }
+         }
+      if (ret[i] == NULL)
+        ret[i] = "";
+    }
+
+  tp_svc_connection_interface_avatars_return_from_get_avatar_tokens (context,
+      (const gchar **)ret);
+
+  g_free (ret);
+}
+
+static void
+salut_connection_get_known_avatar_tokens (
+    TpSvcConnectionInterfaceAvatars *iface, const GArray *contacts,
+    DBusGMethodInvocation *context)
+{
+  guint i;
+  GHashTable *ret;
+  GError *err = NULL;
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *handle_repo;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  handle_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_CONTACT);
+
+  if (!tp_handles_are_valid (handle_repo, contacts, FALSE, &err))
+    {
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      return;
+    }
+
+  ret = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
+
+  for (i = 0; i < contacts->len ; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+      gchar *tokens = NULL;
+
+      if (base->self_handle == handle)
+        {
+          tokens = g_strdup (priv->self->avatar_token);
+        }
+      else
+        {
+          SalutContact *contact;
+          contact =
+             salut_contact_manager_get_contact (priv->contact_manager, handle);
+          if (contact != NULL)
+            {
+              if (contact->avatar_token != NULL)
+                tokens  = g_strdup (contact->avatar_token);
+              else
+                /* We always know the tokens, if it's unset then it's "" */
+                tokens = g_strdup ("");
+              g_object_unref (contact);
+            }
+        }
+
+      if (tokens != NULL)
+        g_hash_table_insert (ret, GUINT_TO_POINTER (handle), tokens);
+    }
+
+  tp_svc_connection_interface_avatars_return_from_get_known_avatar_tokens (
+     context, ret);
+
+  g_hash_table_destroy (ret);
+}
+
+static void
+salut_connection_avatars_fill_contact_attributes (GObject *obj,
+    const GArray *contacts, GHashTable *attributes_hash)
+{
+  guint i;
+  SalutConnection *self = SALUT_CONNECTION (obj);
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  SalutConnectionPrivate *priv = self->priv;
+
+  for (i = 0; i < contacts->len; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+      gchar *token = NULL;
+
+      if (base->self_handle == handle)
+        {
+          token = g_strdup (priv->self->avatar_token);
+        }
+      else
+        {
+          SalutContact *contact = salut_contact_manager_get_contact (
+              priv->contact_manager, handle);
+          if (contact != NULL)
+            {
+              if (contact->avatar_token != NULL)
+                token = g_strdup (contact->avatar_token);
+              else
+                /* We always know the tokens, if it's unset then it's "" */
+                token = g_strdup ("");
+
+              g_object_unref (contact);
+            }
+        }
+
+      if (token != NULL)
+        {
+          GValue *val = tp_g_value_slice_new (G_TYPE_STRING);
+
+          g_value_take_string (val, token);
+
+          tp_contacts_mixin_set_contact_attribute (attributes_hash, handle,
+            TP_IFACE_CONNECTION_INTERFACE_AVATARS"/token", val);
+        }
+    }
+}
+
+
+static void
+_request_avatars_cb (SalutContact *contact, guint8 *avatar, gsize size,
+    gpointer user_data)
+{
+  GArray *arr;
+
+  if (avatar == NULL)
+    return;
+
+  arr = g_array_sized_new (FALSE, FALSE, sizeof (guint8), size);
+  arr = g_array_append_vals (arr, avatar, size);
+
+  tp_svc_connection_interface_avatars_emit_avatar_retrieved (
+    (GObject *) user_data, contact->handle,
+    contact->avatar_token, arr, "");
+
+  g_array_free (arr, TRUE);
+}
+
+static void
+salut_connection_request_avatars (
+    TpSvcConnectionInterfaceAvatars *iface,
+    const GArray *contacts,
+    DBusGMethodInvocation *context)
+{
+  guint i;
+  GError *err = NULL;
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  TpHandleRepoIface *handle_repo;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  handle_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_CONTACT);
+
+  if (!tp_handles_are_valid (handle_repo, contacts, FALSE, &err))
+    {
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      return;
+    }
+
+  for (i = 0; i < contacts->len ; i++)
+    {
+      TpHandle handle = g_array_index (contacts, TpHandle, i);
+
+      if (base->self_handle == handle)
+        {
+           GArray *arr;
+
+           if (priv->self->avatar != NULL)
+             {
+               arr = g_array_sized_new (FALSE, FALSE, sizeof (guint8),
+                 priv->self->avatar_size);
+               arr = g_array_append_vals (arr, priv->self->avatar,
+                 priv->self->avatar_size);
+
+               tp_svc_connection_interface_avatars_emit_avatar_retrieved (
+                  (GObject *) self, base->self_handle,
+                    priv->self->avatar_token, arr, "");
+               g_array_free (arr, TRUE);
+             }
+        }
+      else
+        {
+          SalutContact *contact;
+          contact =
+             salut_contact_manager_get_contact (priv->contact_manager, handle);
+          if (contact != NULL)
+            {
+              salut_contact_get_avatar (contact, _request_avatars_cb, self);
+              g_object_unref (contact);
+            }
+        }
+    }
+
+  tp_svc_connection_interface_avatars_return_from_request_avatars (context);
+}
+
+static void
+_request_avatar_cb (SalutContact *contact, guint8 *avatar, gsize size,
+                   gpointer user_data)
+{
+  DBusGMethodInvocation *context = (DBusGMethodInvocation *) user_data;
+
+  GError *err = NULL;
+  GArray *arr;
+
+  if (size == 0)
+    {
+      err = g_error_new (TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
+                         "Unable to get avatar");
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      return;
+  }
+
+  arr = g_array_sized_new (FALSE, FALSE, sizeof (guint8), size);
+  arr = g_array_append_vals (arr, avatar, size);
+  tp_svc_connection_interface_avatars_return_from_request_avatar (context,
+      arr, "");
+  g_array_free (arr, TRUE);
+}
+
+static void
+salut_connection_request_avatar (TpSvcConnectionInterfaceAvatars *iface,
+    guint handle, DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  SalutContact *contact;
+  GError *err = NULL;
+  TpHandleRepoIface *handle_repo;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  handle_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_CONTACT);
+
+  if (!tp_handle_is_valid (handle_repo, handle, &err))
+    {
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      return;
+    }
+
+  if (handle == base->self_handle)
+    {
+      _request_avatar_cb (NULL, priv->self->avatar, priv->self->avatar_size,
+        context);
+      return;
+    }
+
+  contact = salut_contact_manager_get_contact (priv->contact_manager, handle);
+  if (contact == NULL || contact->avatar_token == NULL)
+    {
+      err = g_error_new (TP_ERRORS, TP_ERROR_NOT_AVAILABLE, "No known avatar");
+      dbus_g_method_return_error (context, err);
+      g_error_free (err);
+      if (contact != NULL)
+        {
+          g_object_unref (contact);
+        }
+      return;
+    }
+  salut_contact_get_avatar (contact, _request_avatar_cb, context);
+  g_object_unref (contact);
+}
+
+static void
+conn_avatars_properties_getter (GObject *object,
+                                GQuark interface,
+                                GQuark name,
+                                GValue *value,
+                                gpointer getter_data)
+{
+  GQuark q_mime_types = g_quark_from_static_string (
+      "SupportedAvatarMIMETypes");
+
+  if (name == q_mime_types)
+    {
+      g_value_set_static_boxed (value, mimetypes);
+    }
+  else
+    {
+      g_value_set_uint (value, GPOINTER_TO_UINT (getter_data));
+    }
+}
+
+static void
+salut_connection_get_avatar_requirements (
+    TpSvcConnectionInterfaceAvatars *iface, DBusGMethodInvocation *context)
+{
+  tp_svc_connection_interface_avatars_return_from_get_avatar_requirements (
+      context, mimetypes, AVATAR_MIN_PX, AVATAR_MIN_PX, AVATAR_MAX_PX,
+      AVATAR_MAX_PX, AVATAR_MAX_BYTES);
+}
+
+static void
+salut_connection_avatar_service_iface_init (gpointer g_iface,
+    gpointer iface_data)
+{
+  TpSvcConnectionInterfaceAvatarsClass *klass =
+       (TpSvcConnectionInterfaceAvatarsClass *) g_iface;
+
+#define IMPLEMENT(x) tp_svc_connection_interface_avatars_implement_##x \
+    (klass, salut_connection_##x)
+  IMPLEMENT (get_avatar_requirements);
+  IMPLEMENT (get_avatar_tokens);
+  IMPLEMENT (get_known_avatar_tokens);
+  IMPLEMENT (request_avatar);
+  IMPLEMENT (request_avatars);
+  IMPLEMENT (set_avatar);
+  IMPLEMENT (clear_avatar);
+#undef IMPLEMENT
+}
+
+static void
+salut_free_enhanced_contact_capabilities (GPtrArray *caps)
+{
+  guint i;
+
+  for (i = 0; i < caps->len; i++)
+    {
+      GValue monster = {0, };
+
+      g_value_init (&monster, TP_STRUCT_TYPE_REQUESTABLE_CHANNEL_CLASS);
+      g_value_take_boxed (&monster, g_ptr_array_index (caps, i));
+      g_value_unset (&monster);
+    }
+
+  g_ptr_array_free (caps, TRUE);
+}
+
+/**
+ * salut_connection_get_contact_capabilities
+ *
+ * Implements D-Bus method GetContactCapabilities
+ * on interface
+ * org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities
+ */
+static void
+salut_connection_get_contact_capabilities (
+    TpSvcConnectionInterfaceContactCapabilities *iface,
+    const GArray *handles,
+    DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  TpHandleRepoIface *contact_handles = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_CONTACT);
+  guint i;
+  GHashTable *ret;
+  GError *error = NULL;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!tp_handles_are_valid (contact_handles, handles, FALSE, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+
+  ret = g_hash_table_new_full (NULL, NULL, NULL,
+      (GDestroyNotify) salut_free_enhanced_contact_capabilities);
+
+  for (i = 0; i < handles->len; i++)
+    {
+      GPtrArray *arr = g_ptr_array_new ();
+      TpHandle handle = g_array_index (handles, TpHandle, i);
+
+      salut_connection_get_handle_contact_capabilities (self, handle, arr);
+
+      g_hash_table_insert (ret, GINT_TO_POINTER (handle), arr);
+    }
+
+  tp_svc_connection_interface_contact_capabilities_return_from_get_contact_capabilities
+      (context, ret);
+
+  g_hash_table_destroy (ret);
+}
+
+
+static void
+_emit_contact_capabilities_changed (SalutConnection *conn,
+                                    TpHandle handle)
+{
+  GPtrArray *ret = g_ptr_array_new ();
+  GHashTable *caps = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+  salut_connection_get_handle_contact_capabilities (conn, handle, ret);
+  g_hash_table_insert (caps, GUINT_TO_POINTER (handle), ret);
+
+  tp_svc_connection_interface_contact_capabilities_emit_contact_capabilities_changed (
+      conn, caps);
+
+  salut_free_enhanced_contact_capabilities (ret);
+  g_hash_table_destroy (caps);
+}
+
+static void
+connection_capabilities_update_cb (SalutPresenceCache *cache,
+                                   TpHandle handle,
+                                   gpointer user_data)
+{
+  SalutConnection *conn = SALUT_CONNECTION (user_data);
+
+  g_assert (SALUT_IS_CONNECTION (user_data));
+
+  _emit_contact_capabilities_changed (conn, handle);
+}
+
+static gboolean
+data_forms_equal (GPtrArray *one,
+    GPtrArray *two)
+{
+  guint i;
+
+  /* These data form lists come from the channel managers returning
+   * from represent_client so they'll be created new every time
+   * represent_client is called. As a result, we can't just look at
+   * the object pointers, like how we can in the presence cache. */
+
+  if (one->len != two->len)
+    return FALSE;
+
+  for (i = 0; i < one->len; i++)
+    {
+      WockyDataForm *form = g_ptr_array_index (one, i);
+      WockyDataFormField *type_field;
+      const gchar *type;
+      guint j;
+      gboolean found = FALSE;
+
+      type_field = g_hash_table_lookup (form->fields, "FORM_TYPE");
+      type = g_value_get_string (type_field->default_value);
+
+      for (j = 0; j < two->len; j++)
+        {
+          WockyDataForm *two_form = g_ptr_array_index (two, i);
+          WockyDataFormField *two_type;
+
+          two_type = g_hash_table_lookup (two_form->fields,
+              "FORM_TYPE");
+
+          if (!tp_strdiff (g_value_get_string (two_type->default_value), type))
+            {
+              found = TRUE;
+              break;
+            }
+        }
+
+      if (!found)
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+/**
+ * salut_connection_update_capabilities
+ *
+ * Implements D-Bus method UpdateCapabilities
+ * on interface
+ * org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities
+ */
+static void
+salut_connection_update_capabilities (
+    TpSvcConnectionInterfaceContactCapabilities *iface,
+    const GPtrArray *clients,
+    DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  SalutConnectionPrivate *priv = self->priv;
+  GabbleCapabilitySet *before = NULL, *after;
+  GPtrArray *before_forms = NULL, *after_forms;
+  TpChannelManagerIter iter;
+  TpChannelManager *manager;
+  guint i;
+  GError *error = NULL;
+
+  /* these are the caps we were advertising before UpdateCapabilities
+   * was called. we'll only have created the salut self once we've
+   * connected */
+  if (priv->self != NULL)
+    {
+      before = gabble_capability_set_copy (salut_self_get_caps (priv->self));
+      before_forms = g_ptr_array_ref (
+          (GPtrArray *) wocky_xep_0115_capabilities_get_data_forms (
+              WOCKY_XEP_0115_CAPABILITIES (priv->self)));
+    }
+
+  tp_base_connection_channel_manager_iter_init (&iter, base);
+
+  while (tp_base_connection_channel_manager_iter_next (&iter, &manager))
+    {
+      /* all channel managers must implement the capability interface */
+      g_assert (GABBLE_IS_CAPS_CHANNEL_MANAGER (manager));
+
+      gabble_caps_channel_manager_reset_capabilities (
+          GABBLE_CAPS_CHANNEL_MANAGER (manager));
+    }
+
+  DEBUG ("enter");
+
+  /* we're going to reset our self caps to the bare caps that we
+   * advertise and then add to it after iterating the clients.  */
+  after = salut_dup_self_advertised_caps ();
+  after_forms = g_ptr_array_new ();
+
+  for (i = 0; i < clients->len; i++)
+    {
+      GValueArray *va = g_ptr_array_index (clients, i);
+      const gchar *client_name = g_value_get_string (va->values + 0);
+      const GPtrArray *filters = g_value_get_boxed (va->values + 1);
+      const gchar * const * cap_tokens = g_value_get_boxed (va->values + 2);
+
+      /* We pass the client through to the caps channel managers
+       * because it allows them to update their view on which clients
+       * are still around. */
+
+      tp_base_connection_channel_manager_iter_init (&iter, base);
+
+      while (tp_base_connection_channel_manager_iter_next (&iter, &manager))
+        {
+          /* all channel managers must implement the capability interface */
+          g_assert (GABBLE_IS_CAPS_CHANNEL_MANAGER (manager));
+
+          gabble_caps_channel_manager_represent_client (
+              GABBLE_CAPS_CHANNEL_MANAGER (manager), client_name, filters,
+              cap_tokens, after, after_forms);
+        }
+    }
+
+  if (priv->self != NULL)
+    {
+      /* we've connected and have a SalutSelf, so give the caps to it
+       * right now */
+      salut_self_take_caps (priv->self, after);
+      salut_self_take_data_forms (priv->self, after_forms);
+    }
+  else
+    {
+      if (priv->pre_connect_caps != NULL)
+        gabble_capability_set_free (priv->pre_connect_caps);
+      if (priv->pre_connect_data_forms != NULL)
+        g_ptr_array_unref (priv->pre_connect_data_forms);
+
+      priv->pre_connect_caps = after;
+      priv->pre_connect_data_forms = after_forms;
+    }
+
+  if ((before != NULL && !gabble_capability_set_equals (before, after))
+      || (before_forms != NULL && !data_forms_equal (before_forms, after_forms)))
+    {
+      if (DEBUGGING)
+        {
+          gchar *dump = gabble_capability_set_dump (after, "  ");
+          DEBUG ("updated caps:\n%s", dump);
+          g_free (dump);
+        }
+
+      if (!announce_self_caps (self, &error))
+        {
+          gabble_capability_set_free (before);
+          dbus_g_method_return_error (context, error);
+          g_error_free (error);
+          return;
+        }
+
+      _emit_contact_capabilities_changed (self, base->self_handle);
+    }
+
+  /* after now belongs to SalutSelf, or priv->pre_connect_caps */
+  if (before != NULL)
+    gabble_capability_set_free (before);
+
+  if (before_forms != NULL)
+    g_ptr_array_unref (before_forms);
+
+  tp_svc_connection_interface_contact_capabilities_return_from_update_capabilities (
+      context);
+}
+
+static void
+salut_conn_contact_caps_iface_init (gpointer g_iface, gpointer iface_data)
+{
+  TpSvcConnectionInterfaceContactCapabilitiesClass *klass =
+    (TpSvcConnectionInterfaceContactCapabilitiesClass *) g_iface;
+
+#define IMPLEMENT(x) \
+    tp_svc_connection_interface_contact_capabilities_implement_##x (\
+    klass, salut_connection_##x)
+  IMPLEMENT(get_contact_capabilities);
+  IMPLEMENT(update_capabilities);
+#undef IMPLEMENT
+}
+
+
+#ifdef ENABLE_OLPC
+static GValue *
+new_gvalue (GType type)
+{
+  GValue *result = g_slice_new0 (GValue);
+  g_value_init (result, type);
+  return result;
+}
+
+static GHashTable *
+get_properties_hash (const GArray *key, const gchar *color, const gchar *jid,
+  const gchar *ip4, const gchar *ip6)
+{
+  GHashTable *properties;
+  GValue *gvalue;
+
+  properties = g_hash_table_new_full (g_str_hash, g_str_equal,
+      NULL, (GDestroyNotify) tp_g_value_slice_free);
+  if (key != NULL)
+    {
+      gvalue = new_gvalue (DBUS_TYPE_G_UCHAR_ARRAY);
+      g_value_set_boxed (gvalue, key);
+      g_hash_table_insert (properties, "key", gvalue);
+    }
+
+  if (color != NULL)
+    {
+      gvalue = new_gvalue (G_TYPE_STRING);
+      g_value_set_string (gvalue, color);
+      g_hash_table_insert (properties, "color", gvalue);
+    }
+
+  if (jid != NULL)
+    {
+      gvalue = new_gvalue (G_TYPE_STRING);
+      g_value_set_string (gvalue, jid);
+      g_hash_table_insert (properties, "jid", gvalue);
+    }
+
+  if (ip4 != NULL)
+    {
+      gvalue = new_gvalue (G_TYPE_STRING);
+      g_value_set_string (gvalue, ip4);
+      g_hash_table_insert (properties, "ip4-address", gvalue);
+    }
+
+  if (ip6 != NULL)
+    {
+      gvalue = new_gvalue (G_TYPE_STRING);
+      g_value_set_string (gvalue, ip6);
+      g_hash_table_insert (properties, "ip6-address", gvalue);
+    }
+
+  return properties;
+}
+
+static void
+emit_properties_changed (SalutConnection *connection,
+                         TpHandle handle,
+                         const GArray *key,
+                         const gchar *color,
+                         const gchar *jid,
+                         const gchar *ip4,
+                         const gchar *ip6)
+{
+  GHashTable *properties;
+  properties = get_properties_hash (key, color, jid, ip4, ip6);
+
+  salut_svc_olpc_buddy_info_emit_properties_changed (connection,
+      handle, properties);
+
+  g_hash_table_destroy (properties);
+}
+
+static void
+append_activity (SalutOlpcActivity *activity,
+                 gpointer user_data)
+{
+  GPtrArray *arr = user_data;
+  GType type = ACTIVITY_PAIR_TYPE;
+  GValue gvalue = {0};
+
+  g_value_init (&gvalue, type);
+  g_value_take_boxed (&gvalue,
+      dbus_g_type_specialized_construct (type));
+
+  dbus_g_type_struct_set (&gvalue,
+      0, activity->id,
+      1, activity->room,
+      G_MAXUINT);
+  g_ptr_array_add (arr, g_value_get_boxed (&gvalue));
+}
+
+static void
+free_olpc_activities (GPtrArray *arr)
+{
+  GType type = ACTIVITY_PAIR_TYPE;
+  guint i;
+
+  for (i = 0; i < arr->len; i++)
+    g_boxed_free (type, arr->pdata[i]);
+
+  g_ptr_array_free (arr, TRUE);
+}
+
+static void
+_contact_manager_contact_olpc_activities_changed (SalutConnection *self,
+                                                  SalutContact *contact,
+                                                  TpHandle handle)
+{
+  GPtrArray *activities = g_ptr_array_new ();
+
+  DEBUG ("called for %u", handle);
+
+  salut_contact_foreach_olpc_activity (contact, append_activity, activities);
+  salut_svc_olpc_buddy_info_emit_activities_changed (self,
+      handle, activities);
+  free_olpc_activities (activities);
+}
+
+static void
+_contact_manager_contact_olpc_properties_changed (SalutConnection *self,
+                                                  SalutContact *contact,
+                                                  TpHandle handle)
+{
+  emit_properties_changed (self, handle, contact->olpc_key,
+      contact->olpc_color, contact->jid, contact->olpc_ip4, contact->olpc_ip6);
+}
+
+static gboolean
+check_handle (TpHandleRepoIface *handle_repo,
+              TpHandle handle,
+              DBusGMethodInvocation *context)
+{
+  GError *error = NULL;
+
+  if (!tp_handle_is_valid (handle_repo, handle, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+check_contact (TpBaseConnection *base,
+               TpHandle contact,
+               DBusGMethodInvocation *context)
+{
+  TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
+      base, TP_HANDLE_TYPE_CONTACT);
+
+  return check_handle (contact_repo, contact, context);
+}
+
+static gboolean
+check_room (TpBaseConnection *base,
+            TpHandle contact,
+            DBusGMethodInvocation *context)
+{
+  TpHandleRepoIface *room_repo = tp_base_connection_get_handles (
+      base, TP_HANDLE_TYPE_ROOM);
+
+  return check_handle (room_repo, contact, context);
+}
+
+static void
+salut_connection_olpc_get_properties (SalutSvcOLPCBuddyInfo *iface,
+                                      TpHandle handle,
+                                      DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  GHashTable *properties = NULL;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!check_contact (base, handle, context))
+    return;
+
+  if (handle == base->self_handle)
+    {
+      properties = get_properties_hash (priv->self->olpc_key,
+          priv->self->olpc_color, priv->self->jid, NULL, NULL);
+    }
+  else
+    {
+      SalutContact *contact;
+      contact = salut_contact_manager_get_contact (priv->contact_manager,
+          handle);
+      if (contact == NULL)
+        {
+          /* FIXME: should this be InvalidHandle? */
+          GError e = { TP_ERRORS, TP_ERROR_NOT_AVAILABLE, "Unknown contact" };
+          dbus_g_method_return_error (context, &e);
+          return;
+        }
+      properties = get_properties_hash (contact->olpc_key, contact->olpc_color,
+        contact->jid, contact->olpc_ip4, contact->olpc_ip6);
+      g_object_unref (contact);
+    }
+
+  salut_svc_olpc_buddy_info_return_from_get_properties (context, properties);
+  g_hash_table_destroy (properties);
+}
+
+
+static gboolean
+find_unknown_properties (gpointer key,
+                         gpointer value,
+                         gpointer user_data)
+{
+  gchar **valid_props = (gchar **) user_data;
+  int i;
+  for (i = 0; valid_props[i] != NULL; i++)
+    {
+      if (!tp_strdiff (key, valid_props[i]))
+        return FALSE;
+    }
+  return TRUE;
+}
+
+static void
+salut_connection_olpc_set_properties (SalutSvcOLPCBuddyInfo *iface,
+                                      GHashTable *properties,
+                                      DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+
+  GError *error = NULL;
+  /* Only a few known properties, so handle it quite naively */
+  const gchar *known_properties[] = { "color", "key", "jid", "ip4-address",
+     "ip6-address", NULL };
+  const gchar *color = NULL;
+  const GArray *key = NULL;
+  const gchar *jid = NULL;
+  const GValue *val;
+
+  /* this function explicitly supports being called when DISCONNECTED
+   * or CONNECTING */
+
+  if (g_hash_table_find (properties, find_unknown_properties, known_properties)
+      != NULL)
+    {
+      error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+          "Unknown property given");
+      goto error;
+    }
+
+  val = (const GValue *) g_hash_table_lookup (properties, "color");
+  if (val != NULL)
+    {
+      if (G_VALUE_TYPE (val) != G_TYPE_STRING)
+        {
+          error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "Color value should be of type s");
+          goto error;
+        }
+      else
+        {
+          int len;
+          gboolean correct = TRUE;
+
+          color = g_value_get_string (val);
+
+          /* be very anal about the color format */
+          len = strlen (color);
+          if (len != 15)
+            {
+              correct = FALSE;
+            }
+          else
+            {
+              int i;
+              for (i = 0 ; i < len ; i++)
+                {
+                  switch (i)
+                    {
+                      case 0:
+                      case 8:
+                        correct = (color[i] == '#');
+                        break;
+                      case 7:
+                        correct = (color[i] == ',');
+                        break;
+                      default:
+                        correct = isxdigit (color[i]);
+                        break;
+                    }
+                }
+            }
+
+          if (!correct)
+            {
+              error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+                  "Color value has an incorrect format");
+              goto error;
+            }
+        }
+    }
+
+  if ((val = (const GValue *) g_hash_table_lookup (properties, "key")) != NULL)
+    {
+      if (G_VALUE_TYPE (val) != DBUS_TYPE_G_UCHAR_ARRAY)
+        {
+          error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "Key value should be of type ay");
+          goto error;
+        }
+      else
+        {
+          key = g_value_get_boxed (val);
+          if (key->len == 0)
+            {
+              error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+                  "Key value of length 0 not allowed");
+              goto error;
+            }
+        }
+    }
+
+  val = g_hash_table_lookup (properties, "jid");
+  if (val != NULL)
+    {
+      if (G_VALUE_TYPE (val) != G_TYPE_STRING)
+        {
+          error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "JID value should be of type s");
+          goto error;
+        }
+
+      jid = g_value_get_string (val);
+
+      if (strchr (jid, '@') == NULL)
+        {
+          error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "JID value has an incorrect format");
+          goto error;
+        }
+    }
+
+  if (priv->self)
+    {
+      if (!salut_self_set_olpc_properties (priv->self, key, color, jid,
+            &error))
+        goto error;
+    }
+  else
+    {
+      /* queue it up for later */
+      if (key)
+        {
+          if (priv->olpc_key == NULL)
+            {
+              priv->olpc_key = g_array_sized_new (FALSE, FALSE, sizeof (guint8),
+                  key->len);
+            }
+          else
+            {
+              g_array_remove_range (priv->olpc_key, 0, priv->olpc_key->len);
+            }
+          g_array_append_vals (priv->olpc_key, key->data, key->len);
+        }
+      if (color)
+        {
+          g_free (priv->olpc_color);
+          priv->olpc_color = g_strdup (color);
+        }
+      if (jid)
+        {
+          g_free (priv->jid);
+          priv->jid = g_strdup (jid);
+        }
+    }
+
+  salut_svc_olpc_buddy_info_return_from_set_properties (context);
+  return;
+
+error:
+  dbus_g_method_return_error (context, error);
+  g_error_free (error);
+}
+
+static void
+salut_connection_olpc_get_current_activity (SalutSvcOLPCBuddyInfo *iface,
+                                            TpHandle handle,
+                                            DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  SalutConnectionPrivate *priv = self->priv;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  DEBUG ("called for %u", handle);
+
+  if (!check_contact (base, handle, context))
+    return;
+
+  if (handle == base->self_handle)
+    {
+      DEBUG ("Returning my own cur.act.: %s -> %u",
+          priv->self->olpc_cur_act ? priv->self->olpc_cur_act : "",
+          priv->self->olpc_cur_act_room);
+      salut_svc_olpc_buddy_info_return_from_get_current_activity (context,
+          priv->self->olpc_cur_act ? priv->self->olpc_cur_act : "",
+          priv->self->olpc_cur_act_room);
+    }
+  else
+    {
+      SalutContact *contact = salut_contact_manager_get_contact
+        (priv->contact_manager, handle);
+
+      if (contact == NULL)
+        {
+          /* FIXME: should this be InvalidHandle? */
+          GError e = { TP_ERRORS, TP_ERROR_NOT_AVAILABLE, "Unknown contact" };
+          DEBUG ("Returning error: unknown contact");
+          dbus_g_method_return_error (context, &e);
+          return;
+        }
+
+      DEBUG ("Returning buddy %u cur.act.: %s -> %u", handle,
+          contact->olpc_cur_act ? contact->olpc_cur_act : "",
+          contact->olpc_cur_act_room);
+      salut_svc_olpc_buddy_info_return_from_get_current_activity (context,
+          contact->olpc_cur_act ? contact->olpc_cur_act : "",
+          contact->olpc_cur_act_room);
+      g_object_unref (contact);
+    }
+}
+
+static void
+salut_connection_olpc_set_current_activity (SalutSvcOLPCBuddyInfo *iface,
+                                            const gchar *activity_id,
+                                            TpHandle room_handle,
+                                            DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  GError *error = NULL;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  DEBUG ("called");
+
+  if (activity_id[0] == '\0')
+    {
+      if (room_handle != 0)
+        {
+          GError e = { TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "If activity ID is empty, room handle must be 0" };
+
+          dbus_g_method_return_error (context, &e);
+          return;
+        }
+    }
+  else
+    {
+      if (!check_room (base, room_handle, context))
+        return;
+    }
+
+  if (!salut_self_set_olpc_current_activity (priv->self, activity_id,
+        room_handle, &error))
+    {
+      dbus_g_method_return_error (context, error);
+      g_error_free (error);
+      return;
+    }
+
+  salut_svc_olpc_buddy_info_return_from_set_current_activity (context);
+}
+
+static void
+salut_connection_olpc_get_activities (SalutSvcOLPCBuddyInfo *iface,
+                                      TpHandle handle,
+                                      DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  GPtrArray *arr;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  DEBUG ("called for %u", handle);
+
+  if (!check_contact (base, handle, context))
+    return;
+
+  if (handle == base->self_handle)
+    {
+      arr = g_ptr_array_new ();
+      salut_self_foreach_olpc_activity (priv->self, append_activity, arr);
+    }
+  else
+    {
+      SalutContact *contact = salut_contact_manager_get_contact
+        (priv->contact_manager, handle);
+
+      if (contact == NULL)
+        {
+          /* FIXME: should this be InvalidHandle? */
+          GError e = { TP_ERRORS, TP_ERROR_NOT_AVAILABLE, "Unknown contact" };
+          DEBUG ("Returning error: unknown contact");
+          dbus_g_method_return_error (context, &e);
+          return;
+        }
+
+      arr = g_ptr_array_new ();
+      salut_contact_foreach_olpc_activity (contact, append_activity, arr);
+      g_object_unref (contact);
+    }
+
+  salut_svc_olpc_buddy_info_return_from_get_activities (context, arr);
+  free_olpc_activities (arr);
+}
+
+static void
+salut_connection_olpc_set_activities (SalutSvcOLPCBuddyInfo *iface,
+                                      const GPtrArray *activities,
+                                      DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  TpHandleRepoIface *room_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_ROOM);
+  GHashTable *room_to_act_id = g_hash_table_new_full (g_direct_hash,
+      g_direct_equal, NULL, (GDestroyNotify) g_free);
+  GError *error = NULL;
+  guint i;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  for (i = 0; i < activities->len; i++)
+    {
+      GValue pair = {0};
+      gchar *activity;
+      guint room_handle;
+
+      g_value_init (&pair, ACTIVITY_PAIR_TYPE);
+      g_value_set_static_boxed (&pair, g_ptr_array_index (activities, i));
+      dbus_g_type_struct_get (&pair,
+          0, &activity,
+          1, &room_handle,
+          G_MAXUINT);
+
+      if (activity[0] == '\0')
+        {
+          GError e = { TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "Invalid empty activity ID" };
+
+          DEBUG ("%s", e.message);
+          dbus_g_method_return_error (context, &e);
+          g_free (activity);
+          goto finally;
+        }
+
+      if (!tp_handle_is_valid (room_repo, room_handle, &error))
+        {
+          DEBUG ("Invalid room handle %u: %s", room_handle, error->message);
+          dbus_g_method_return_error (context, error);
+          g_error_free (error);
+          g_free (activity);
+          goto finally;
+        }
+
+      g_hash_table_insert (room_to_act_id, GUINT_TO_POINTER (room_handle),
+          activity);
+    }
+
+  if (!salut_self_set_olpc_activities (priv->self, room_to_act_id, &error))
+    {
+      dbus_g_method_return_error (context, error);
+    }
+  else
+    {
+      salut_svc_olpc_buddy_info_return_from_set_activities (context);
+    }
+
+finally:
+  g_hash_table_destroy (room_to_act_id);
+}
+
+static void
+salut_connection_olpc_add_activity (SalutSvcOLPCBuddyInfo *iface,
+                                    const gchar *id,
+                                    TpHandle handle,
+                                    DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  GError *error = NULL;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!salut_self_add_olpc_activity (priv->self, id, handle, &error))
+    {
+      dbus_g_method_return_error (context, error);
+    }
+  else
+    {
+      salut_svc_olpc_buddy_info_return_from_set_activities (context);
+    }
+}
+
+static void
+salut_connection_olpc_buddy_info_iface_init (gpointer g_iface,
+                                             gpointer iface_data)
+{
+  SalutSvcOLPCBuddyInfoClass *klass =
+    (SalutSvcOLPCBuddyInfoClass *) g_iface;
+#define IMPLEMENT(x) salut_svc_olpc_buddy_info_implement_##x (klass, \
+    salut_connection_olpc_##x)
+  IMPLEMENT(set_properties);
+  IMPLEMENT(get_properties);
+  IMPLEMENT(set_activities);
+  IMPLEMENT(add_activity);
+  IMPLEMENT(get_activities);
+  IMPLEMENT(set_current_activity);
+  IMPLEMENT(get_current_activity);
+#undef IMPLEMENT
+}
+
+static void
+salut_connection_act_get_properties (SalutSvcOLPCActivityProperties *iface,
+                                     TpHandle handle,
+                                     DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  TpHandleRepoIface *room_repo = tp_base_connection_get_handles (base,
+      TP_HANDLE_TYPE_ROOM);
+  GHashTable *properties = NULL;
+  GError *error = NULL;
+  SalutOlpcActivity *activity;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!tp_handle_is_valid (room_repo, handle, &error))
+    goto error;
+
+  activity = salut_olpc_activity_manager_get_activity_by_room (
+      priv->olpc_activity_manager, handle);
+  if (activity == NULL)
+    {
+      g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
+          "Activity unknown: %u", handle);
+      goto error;
+    }
+
+  properties = salut_olpc_activity_create_properties_table (activity);
+
+  salut_svc_olpc_buddy_info_return_from_get_properties (context, properties);
+  g_hash_table_destroy (properties);
+
+  return;
+
+error:
+  dbus_g_method_return_error (context, error);
+  g_error_free (error);
+}
+
+static gboolean
+check_color (const gchar *color)
+{
+  int len, i;
+
+  /* be very anal about the color format */
+  len = strlen (color);
+  if (len != 15)
+    return FALSE;
+
+  for (i = 0 ; i < len ; i++)
+    {
+      switch (i)
+        {
+          case 0:
+          case 8:
+            if (color[i] != '#')
+              return FALSE;
+            break;
+          case 7:
+            if (color[i] != ',')
+              return FALSE;
+            break;
+          default:
+            if (!isxdigit (color[i]))
+              return FALSE;
+            break;
+        }
+    }
+
+  return TRUE;
+}
+
+/* returned strings are only valid as long as the hash table isn't modified */
+static gboolean
+extract_properties_from_hash (GHashTable *properties,
+                              const gchar **id,
+                              const gchar **color,
+                              const gchar **name,
+                              const gchar **type,
+                              const gchar **tags,
+                              gboolean *is_private,
+                              GError **error)
+{
+  GValue *activity_id_val, *color_val, *activity_name_val, *activity_type_val,
+      *tags_val, *is_private_val;
+
+  /* activity ID */
+  activity_id_val = g_hash_table_lookup (properties, "id");
+  if (activity_id_val != NULL)
+    {
+      if (G_VALUE_TYPE (activity_id_val) != G_TYPE_STRING)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "Activity ID value should be of type s");
+          return FALSE;
+        }
+
+      if (id != NULL)
+        *id = g_value_get_string (activity_id_val);
+    }
+
+  /* color */
+  color_val = g_hash_table_lookup (properties, "color");
+  if (color_val != NULL)
+    {
+      if (G_VALUE_TYPE (color_val) != G_TYPE_STRING)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "Color value should be of type s");
+          return FALSE;
+        }
+
+      if (color != NULL)
+        {
+          *color = g_value_get_string (color_val);
+
+           if (!check_color (*color))
+            {
+              g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+                  "Color value has an incorrect format");
+              return FALSE;
+            }
+        }
+    }
+
+  /* name */
+  activity_name_val = g_hash_table_lookup (properties, "name");
+  if (activity_name_val != NULL)
+    {
+      if (G_VALUE_TYPE (activity_name_val) != G_TYPE_STRING)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "name value should be of type s");
+          return FALSE;
+        }
+
+      if (name != NULL)
+        *name = g_value_get_string (activity_name_val);
+    }
+
+  /* type */
+  activity_type_val = g_hash_table_lookup (properties, "type");
+  if (activity_type_val != NULL)
+    {
+      if (G_VALUE_TYPE (activity_type_val) != G_TYPE_STRING)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "type value should be of type s");
+          return FALSE;
+        }
+
+      if (type != NULL)
+        {
+          *type = g_value_get_string (activity_type_val);
+
+          if (*type[0] == '\0')
+            {
+              g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+                  "type value must be non-empty");
+              return FALSE;
+            }
+        }
+    }
+
+  /* tags */
+  tags_val = g_hash_table_lookup (properties, "tags");
+  if (tags_val != NULL)
+    {
+      if (G_VALUE_TYPE (activity_type_val) != G_TYPE_STRING)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "tags value should be of type s");
+          return FALSE;
+        }
+
+      if (type != NULL)
+        *tags = g_value_get_string (tags_val);
+    }
+
+  /* is_private */
+  is_private_val = g_hash_table_lookup (properties, "private");
+  if (is_private_val != NULL)
+    {
+     if (G_VALUE_TYPE (is_private_val) != G_TYPE_BOOLEAN)
+        {
+          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "private value should be of type b");
+          return FALSE;
+        }
+
+      if (is_private != NULL)
+        *is_private = g_value_get_boolean (is_private_val);
+    }
+
+  return TRUE;
+}
+
+static void
+salut_connection_act_set_properties (SalutSvcOLPCActivityProperties *iface,
+                                     TpHandle handle,
+                                     GHashTable *properties,
+                                     DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  GError *error = NULL;
+  const gchar *known_properties[] = { "color", "name", "type", "private",
+      "tags", NULL };
+  const gchar *color = NULL, *name = NULL, *type = NULL, *tags = NULL;
+  gboolean is_private = TRUE;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  if (!check_room (base, handle, context))
+    return;
+
+  if (g_hash_table_find (properties, find_unknown_properties, known_properties)
+      != NULL)
+    {
+      error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+          "Unknown property given");
+      goto error;
+    }
+
+  if (!extract_properties_from_hash (properties, NULL, &color, &name, &type,
+        &tags, &is_private, &error))
+    goto error;
+
+  if (!salut_self_set_olpc_activity_properties (priv->self, handle, color,
+        name, type, tags, is_private, &error))
+    goto error;
+
+  salut_svc_olpc_activity_properties_return_from_set_properties (context);
+  return;
+
+error:
+  dbus_g_method_return_error (context, error);
+  g_error_free (error);
+}
+
+typedef struct
+{
+  SalutContact *inviter;
+  SalutOlpcActivity *activity;
+} muc_ready_ctx;
+
+static muc_ready_ctx *
+muc_ready_ctx_new (SalutContact *inviter,
+                   SalutOlpcActivity *activity)
+{
+  muc_ready_ctx *ctx = g_slice_new (muc_ready_ctx);
+  ctx->inviter = inviter;
+  g_object_ref (inviter);
+  ctx->activity = activity;
+  g_object_ref (activity);
+  return ctx;
+}
+
+static void
+muc_ready_ctx_free (muc_ready_ctx *ctx)
+{
+  if (ctx == NULL)
+    return;
+
+  g_object_unref (ctx->inviter);
+  g_object_unref (ctx->activity);
+  g_slice_free (muc_ready_ctx, ctx);
+}
+
+static void
+muc_ready_cb (SalutMucChannel *muc,
+              muc_ready_ctx *ctx)
+{
+  /* We joined the muc so have to forget about invites */
+  salut_contact_left_activity (ctx->inviter, ctx->activity);
+
+  DEBUG ("forget invite received from %s", ctx->inviter->name);
+  g_signal_handlers_disconnect_matched (muc, G_SIGNAL_MATCH_DATA, 0, 0, NULL,
+      NULL, ctx);
+  muc_ready_ctx_free (ctx);
+}
+
+static void
+muc_closed_cb (SalutMucChannel *muc,
+               muc_ready_ctx *ctx)
+{
+  /* FIXME: should we call left_private_activity here too ? */
+
+  g_signal_handlers_disconnect_matched (muc, G_SIGNAL_MATCH_DATA, 0, 0, NULL,
+      NULL, ctx);
+  muc_ready_ctx_free (ctx);
+}
+
+void
+salut_connection_olpc_observe_invitation (SalutConnection *self,
+                                          TpHandle room,
+                                          TpHandle inviter_handle,
+                                          WockyNode *invite_node)
+{
+  SalutConnectionPrivate *priv = self->priv;
+  WockyNode *props_node;
+  GHashTable *properties;
+  const gchar *activity_id, *color = NULL, *activity_name = NULL,
+        *activity_type = NULL, *tags = NULL;
+  SalutContact *inviter;
+  SalutOlpcActivity *activity;
+  SalutMucChannel *muc;
+  muc_ready_ctx *ctx;
+
+  props_node = wocky_node_get_child_ns (invite_node, "properties",
+      GIBBER_TELEPATHY_NS_OLPC_ACTIVITY_PROPS);
+
+  if (props_node == NULL)
+    return;
+
+  inviter = salut_contact_manager_get_contact (priv->contact_manager,
+      inviter_handle);
+  if (inviter == NULL)
+    return;
+
+  properties = salut_wocky_node_extract_properties (props_node,
+      "property");
+
+  if (!extract_properties_from_hash (properties, &activity_id, &color,
+        &activity_name, &activity_type, &tags, NULL, NULL))
+    return;
+
+  activity = salut_olpc_activity_manager_got_invitation (
+      priv->olpc_activity_manager,
+      room, inviter, activity_id, activity_name, activity_type,
+      color, tags);
+
+  muc = salut_muc_manager_get_text_channel (priv->muc_manager, room);
+  g_assert (muc != NULL);
+
+  ctx = muc_ready_ctx_new (inviter, activity);
+  g_signal_connect (muc, "ready", G_CALLBACK (muc_ready_cb), ctx);
+  g_signal_connect (muc, "closed", G_CALLBACK (muc_closed_cb), ctx);
+
+  g_object_unref (muc);
+  g_hash_table_destroy (properties);
+  g_object_unref (inviter);
+}
+
+static void
+salut_connection_act_get_activity (SalutSvcOLPCActivityProperties *iface,
+                                   const gchar *activity_id,
+                                   DBusGMethodInvocation *context)
+{
+  SalutConnection *self = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = (TpBaseConnection *) self;
+  GError *error = NULL;
+  SalutOlpcActivity *activity;
+
+  TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED (base, context);
+
+  activity = salut_olpc_activity_manager_get_activity_by_id (
+      priv->olpc_activity_manager, activity_id);
+  if (activity == NULL)
+    {
+      g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
+          "Activity unknown: %s", activity_id);
+      goto error;
+    }
+
+  salut_svc_olpc_activity_properties_return_from_get_activity (context,
+      activity->room);
+
+  return;
+
+error:
+  dbus_g_method_return_error (context, error);
+  g_error_free (error);
+}
+
+static void
+salut_connection_olpc_activity_properties_iface_init (gpointer g_iface,
+                                                      gpointer iface_data)
+{
+  SalutSvcOLPCActivityPropertiesClass *klass =
+    (SalutSvcOLPCActivityPropertiesClass *) g_iface;
+#define IMPLEMENT(x) salut_svc_olpc_activity_properties_implement_##x \
+  (klass, salut_connection_act_##x)
+  IMPLEMENT(set_properties);
+  IMPLEMENT(get_properties);
+  IMPLEMENT(get_activity);
+#undef IMPLEMENT
+}
+#endif
+
+gchar *
+salut_normalize_non_empty (const gchar *id,
+    GError **error)
+{
+  g_return_val_if_fail (id != NULL, NULL);
+
+  if (*id == '\0')
+    {
+      g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_HANDLE,
+          "Salut handle names may not be the empty string");
+      return NULL;
+    }
+
+  return g_strdup (id);
+}
+
+static gchar *
+handle_normalize_require_nonempty (TpHandleRepoIface *repo G_GNUC_UNUSED,
+    const gchar *id,
+    gpointer context G_GNUC_UNUSED,
+    GError **error)
+{
+  return salut_normalize_non_empty (id, error);
+}
+
+/* Connection baseclass function implementations */
+static void
+salut_connection_create_handle_repos (TpBaseConnection *self,
+    TpHandleRepoIface *repos[NUM_TP_HANDLE_TYPES])
+{
+  static const char *list_handle_strings[] = {
+    "publish",
+    "subscribe",
+    "known",
+    NULL
+  };
+
+  repos[TP_HANDLE_TYPE_CONTACT] = tp_dynamic_handle_repo_new
+      (TP_HANDLE_TYPE_CONTACT, handle_normalize_require_nonempty, NULL);
+
+  repos[TP_HANDLE_TYPE_ROOM] = tp_dynamic_handle_repo_new
+      (TP_HANDLE_TYPE_ROOM, handle_normalize_require_nonempty, NULL);
+
+  repos[TP_HANDLE_TYPE_LIST] = tp_static_handle_repo_new (TP_HANDLE_TYPE_LIST,
+      list_handle_strings);
+}
+
+static void
+_contact_manager_contact_change_cb (SalutContactManager *mgr,
+    SalutContact *contact, int changes, gpointer data)
+{
+  SalutConnection *self = SALUT_CONNECTION(data);
+  TpHandleRepoIface *handle_repo = tp_base_connection_get_handles (
+      TP_BASE_CONNECTION(self), TP_HANDLE_TYPE_CONTACT);
+  TpHandle handle;
+
+  handle = tp_handle_lookup (handle_repo, contact->name, NULL, NULL);
+
+  if (changes & SALUT_CONTACT_ALIAS_CHANGED)
+    {
+      _contact_manager_contact_alias_changed (self, contact, handle);
+    }
+
+  if (changes & SALUT_CONTACT_STATUS_CHANGED)
+    {
+      _contact_manager_contact_status_changed (self, contact, handle);
+    }
+
+  if (changes & SALUT_CONTACT_AVATAR_CHANGED)
+    {
+      _contact_manager_contact_avatar_changed (self, contact, handle);
+    }
+
+#ifdef ENABLE_OLPC
+  if (changes & SALUT_CONTACT_OLPC_PROPERTIES)
+    _contact_manager_contact_olpc_properties_changed (self, contact, handle);
+
+  if (changes & SALUT_CONTACT_OLPC_CURRENT_ACTIVITY)
+    salut_svc_olpc_buddy_info_emit_current_activity_changed (self,
+        handle, contact->olpc_cur_act, contact->olpc_cur_act_room);
+
+  if (changes & SALUT_CONTACT_OLPC_ACTIVITIES)
+    _contact_manager_contact_olpc_activities_changed (self, contact, handle);
+#endif
+}
+
+#ifdef ENABLE_OLPC
+static void
+_olpc_activity_manager_activity_modified_cb (SalutOlpcActivityManager *mgr,
+  SalutOlpcActivity *activity, SalutConnection *self)
+{
+  GHashTable *properties;
+
+  properties = salut_olpc_activity_create_properties_table (activity);
+  salut_svc_olpc_activity_properties_emit_activity_properties_changed (
+      self, activity->room, properties);
+
+  g_hash_table_destroy (properties);
+}
+
+gboolean
+salut_connection_olpc_observe_muc_stanza (SalutConnection *self,
+    TpHandle room, TpHandle sender, WockyStanza *stanza)
+{
+  WockyNode *node = wocky_stanza_get_top_node (stanza);
+  SalutConnectionPrivate *priv = self->priv;
+  WockyNode *props_node;
+  GHashTable *properties;
+  const gchar *activity_id, *color = NULL, *activity_name = NULL,
+        *activity_type = NULL, *tags = NULL;
+  gboolean is_private = FALSE;
+  SalutOlpcActivity *activity;
+
+  props_node = wocky_node_get_child_ns (node, "properties",
+      GIBBER_TELEPATHY_NS_OLPC_ACTIVITY_PROPS);
+
+  if (props_node == NULL)
+    return FALSE;
+
+  activity = salut_olpc_activity_manager_get_activity_by_room (
+      priv->olpc_activity_manager, room);
+
+  if (activity == NULL)
+    {
+      DEBUG ("no activity in room %d", room);
+      return FALSE;
+    }
+
+  properties = salut_wocky_node_extract_properties (props_node,
+      "property");
+
+  if (!extract_properties_from_hash (properties, &activity_id, &color,
+        &activity_name, &activity_type, &tags, &is_private, NULL))
+    return TRUE;
+
+  salut_olpc_activity_update (activity, room, activity_id, activity_name,
+      activity_type, color, tags, is_private);
+
+  g_hash_table_destroy (properties);
+
+  return TRUE;
+}
+
+static gboolean
+uninvite_stanza_callback (WockyPorter *porter,
+    WockyStanza *stanza,
+    gpointer user_data)
+{
+  SalutConnection *self = SALUT_CONNECTION (user_data);
+  SalutConnectionPrivate *priv = self->priv;
+  TpHandleRepoIface *room_repo = tp_base_connection_get_handles (
+      (TpBaseConnection *) self, TP_HANDLE_TYPE_ROOM);
+  WockyNode *node;
+  TpHandle room_handle;
+  const gchar *room, *activity_id;
+  SalutOlpcActivity *activity;
+  WockyNode *top_node = wocky_stanza_get_top_node (stanza);
+  SalutContact *contact = SALUT_CONTACT (wocky_stanza_get_from_contact (stanza));
+
+  node = wocky_node_get_child_ns (top_node, "uninvite",
+        GIBBER_TELEPATHY_NS_OLPC_ACTIVITY_PROPS);
+  g_assert (node != NULL);
+
+  room = wocky_node_get_attribute (node, "room");
+  if (room == NULL)
+    {
+      DEBUG ("No room attribute");
+      return FALSE;
+    }
+
+  room_handle = tp_handle_lookup (room_repo, room, NULL, NULL);
+  if (room_handle == 0)
+    {
+      DEBUG ("room %s unknown", room);
+      return FALSE;
+    }
+
+  activity_id = wocky_node_get_attribute (node, "id");
+  if (activity_id == NULL)
+    {
+      DEBUG ("No id attribute");
+      return FALSE;
+    }
+
+  DEBUG ("received uninvite from %s", contact->name);
+
+  activity = salut_olpc_activity_manager_get_activity_by_room (
+      priv->olpc_activity_manager, room_handle);
+
+  if (activity == NULL)
+    return FALSE;
+
+  salut_contact_left_activity (contact, activity);
+
+  return TRUE;
+}
+
+#endif
+
+static GPtrArray *
+salut_connection_create_channel_factories (TpBaseConnection *base)
+{
+  SalutConnection *self = SALUT_CONNECTION (base);
+  SalutConnectionPrivate *priv = self->priv;
+  GPtrArray *factories = g_ptr_array_sized_new (4);
+
+  /* Create the contact manager */
+  priv->contact_manager = salut_discovery_client_create_contact_manager (
+      priv->discovery_client, self);
+  g_signal_connect (priv->contact_manager, "contact-change",
+      G_CALLBACK (_contact_manager_contact_change_cb), self);
+
+#ifdef ENABLE_OLPC
+  priv->uninvite_handler_id = wocky_porter_register_handler_from_anyone (
+      self->porter,
+      WOCKY_STANZA_TYPE_MESSAGE, WOCKY_STANZA_SUB_TYPE_NONE,
+      WOCKY_PORTER_HANDLER_PRIORITY_NORMAL,
+      uninvite_stanza_callback, self,
+      '(', "uninvite",
+        ':', GIBBER_TELEPATHY_NS_OLPC_ACTIVITY_PROPS,
+      ')', NULL);
+
+  /* create the OLPC activity manager */
+  priv->olpc_activity_manager =
+      salut_discovery_client_create_olpc_activity_manager (
+          priv->discovery_client, self);
+  g_signal_connect (priv->olpc_activity_manager, "activity-modified",
+      G_CALLBACK (_olpc_activity_manager_activity_modified_cb), self);
+#endif
+
+  return factories;
+}
+
+#ifdef ENABLE_OLPC
+static void
+muc_channel_closed_cb (SalutMucChannel *chan,
+                       SalutOlpcActivity *activity)
+{
+  SalutConnection *conn;
+  SalutConnectionPrivate *priv;
+  TpBaseConnection *base;
+  GPtrArray *activities = g_ptr_array_new ();
+
+  g_signal_handlers_disconnect_by_func (chan,
+      G_CALLBACK (muc_channel_closed_cb), activity);
+
+  g_object_get (activity,
+      "connection", &conn,
+      NULL);
+
+  priv = conn->priv;
+  base = (TpBaseConnection *) conn;
+
+  salut_self_remove_olpc_activity (priv->self, activity);
+
+  salut_self_foreach_olpc_activity (priv->self, append_activity, activities);
+  salut_svc_olpc_buddy_info_emit_activities_changed (conn, base->self_handle,
+      activities);
+  free_olpc_activities (activities);
+
+  /* we were holding a ref since the channel was opened */
+  g_object_unref (activity);
+
+  g_object_unref (conn);
+}
+
+static void
+muc_manager_new_channels_cb (TpChannelManager *channel_manager,
+                             GHashTable *channels,
+                             SalutConnection *conn)
+{
+  SalutConnectionPrivate *priv = conn->priv;
+  GHashTableIter iter;
+  gpointer chan;
+
+  g_hash_table_iter_init (&iter, channels);
+  while (g_hash_table_iter_next (&iter, &chan, NULL))
+    {
+      SalutOlpcActivity *activity;
+      TpHandle room_handle;
+
+      if (!SALUT_IS_MUC_CHANNEL (chan))
+        return;
+
+      g_object_get (chan,
+          "handle", &room_handle,
+          NULL);
+
+      /* ref the activity as long as we have a channel open */
+      activity = salut_olpc_activity_manager_ensure_activity_by_room (
+          priv->olpc_activity_manager,
+          room_handle);
+
+      g_signal_connect (chan, "closed", G_CALLBACK (muc_channel_closed_cb),
+          activity);
+    }
+}
+#endif
+
+static void
+add_to_array (gpointer data,
+    gpointer user_data)
+{
+  g_ptr_array_add (user_data, data);
+}
+
+static GPtrArray *
+salut_connection_create_channel_managers (TpBaseConnection *base)
+{
+  SalutConnection *self = SALUT_CONNECTION (base);
+  SalutConnectionPrivate *priv = self->priv;
+  GPtrArray *managers = g_ptr_array_sized_new (1);
+  GPtrArray *tmp;
+  SalutPluginLoader *loader;
+
+  /* FIXME: The second and third arguments depend on create_channel_factories
+   *        being called before this; should telepathy-glib guarantee that or
+   *        should we be defensive?
+   */
+  priv->im_manager = salut_im_manager_new (self, priv->contact_manager);
+
+  priv->ft_manager = salut_ft_manager_new (self, priv->contact_manager);
+
+  priv->muc_manager = salut_discovery_client_create_muc_manager (
+      priv->discovery_client, self);
+
+  priv->roomlist_manager = salut_discovery_client_create_roomlist_manager (
+      priv->discovery_client, self);
+
+#if 0
+  priv->tubes_manager = salut_tubes_manager_new (self, priv->contact_manager);
+#endif
+
+  g_ptr_array_add (managers, priv->im_manager);
+  g_ptr_array_add (managers, priv->contact_manager);
+  g_ptr_array_add (managers, priv->ft_manager);
+  g_ptr_array_add (managers, priv->muc_manager);
+  g_ptr_array_add (managers, priv->roomlist_manager);
+#if 0
+  g_ptr_array_add (managers, priv->tubes_manager);
+#endif
+
+#ifdef ENABLE_OLPC
+  g_signal_connect (TP_CHANNEL_MANAGER (priv->muc_manager), "new-channels",
+      G_CALLBACK (muc_manager_new_channels_cb), self);
+#endif
+
+  /* plugin channel managers */
+  loader = salut_plugin_loader_dup ();
+  tmp = salut_plugin_loader_create_channel_managers (loader, base);
+  g_object_unref (loader);
+
+  g_ptr_array_foreach (tmp, add_to_array, managers);
+  g_ptr_array_free (tmp, TRUE);
+
+  return managers;
+}
+
+
+static gchar *
+salut_connection_get_unique_connection_name (TpBaseConnection *base)
+{
+  SalutConnection *self = SALUT_CONNECTION (base);
+  SalutConnectionPrivate *priv = self->priv;
+
+  return g_strdup (priv->published_name);
+}
+
+static void
+force_close_cb (GObject *source,
+    GAsyncResult *res,
+    gpointer user_data)
+{
+  SalutConnection *self = SALUT_CONNECTION (user_data);
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  GError *error = NULL;
+
+  if (!wocky_porter_force_close_finish (WOCKY_PORTER (source),
+          res, &error))
+    {
+      DEBUG ("force close failed: %s", error->message);
+      g_error_free (error);
+    }
+  else
+    {
+      DEBUG ("connection properly closed (forced)");
+    }
+
+  tp_base_connection_finish_shutdown (base);
+
+  g_object_unref (self);
+}
+
+static void
+closed_cb (GObject *source,
+    GAsyncResult *res,
+    gpointer user_data)
+{
+  SalutConnection *self = SALUT_CONNECTION (user_data);
+  SalutConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  GError *error = NULL;
+  gboolean force_called = priv->disconnect_timer == 0;
+
+  if (priv->disconnect_timer != 0)
+    {
+      /* stop the timer */
+      g_source_remove (priv->disconnect_timer);
+      priv->disconnect_timer = 0;
+    }
+
+  if (!wocky_porter_close_finish (WOCKY_PORTER (source), res, &error))
+    {
+      DEBUG ("close failed: %s", error->message);
+
+      if (g_error_matches (error, WOCKY_PORTER_ERROR,
+            WOCKY_PORTER_ERROR_FORCIBLY_CLOSED))
+        {
+          /* Close operation has been aborted because a force_close operation
+           * has been started. tp_base_connection_finish_shutdown will be
+           * called once this force_close operation is completed so we don't
+           * do it here. */
+
+          g_error_free (error);
+          goto out;
+        }
+
+      g_error_free (error);
+    }
+  else
+    {
+      DEBUG ("connection properly closed");
+    }
+
+  if (!force_called)
+    tp_base_connection_finish_shutdown (base);
+
+out:
+  g_object_unref (self);
+}
+
+static gboolean
+disconnect_timeout_cb (gpointer data)
+{
+  SalutConnection *self = SALUT_CONNECTION (data);
+  SalutConnectionPrivate *priv = self->priv;
+
+  DEBUG ("Close operation timed out. Force closing");
+  priv->disconnect_timer = 0;
+
+  wocky_porter_force_close_async (self->porter, NULL, force_close_cb, g_object_ref (self));
+  return FALSE;
+}
+
+static void
+salut_connection_shut_down (TpBaseConnection *base)
+{
+  SalutConnection *self = SALUT_CONNECTION (base);
+  SalutConnectionPrivate *priv = self->priv;
+
+  _salut_connection_disconnect (self);
+
+  if (self->session != NULL)
+    {
+      DEBUG ("connection may still be open; closing it: %p", self);
+
+      g_assert (priv->disconnect_timer == 0);
+      priv->disconnect_timer = g_timeout_add_seconds (DISCONNECT_TIMEOUT,
+          disconnect_timeout_cb, self);
+
+      wocky_porter_close_async (self->porter, NULL, closed_cb, g_object_ref (self));
+      return;
+    }
+
+  DEBUG ("session is not alive; clean up the base connection");
+  tp_base_connection_finish_shutdown (base);
+}
+
+static gboolean
+salut_connection_start_connecting (TpBaseConnection *base, GError **error)
+{
+  SalutConnection *self = SALUT_CONNECTION (base);
+  SalutConnectionPrivate *priv = self->priv;
+  GError *client_error = NULL;
+
+  g_signal_connect (priv->discovery_client, "state-changed",
+      G_CALLBACK (_discovery_client_state_changed_cb), self);
+
+  if (!salut_discovery_client_start (priv->discovery_client, &client_error))
+    {
+      *error = g_error_new (TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
+          "Unable to initialize the avahi client: %s",
+          client_error->message);
+      DEBUG ("%s", (*error)->message);
+      g_error_free (client_error);
+      goto error;
+    }
+
+  return TRUE;
+
+error:
+  tp_base_connection_change_status (
+        TP_BASE_CONNECTION (base),
+        TP_CONNECTION_STATUS_DISCONNECTED,
+        TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+  return FALSE;
+}
+
+/* sidecar stuff */
+static gchar *
+make_sidecar_path (
+    SalutConnection *conn,
+    const gchar *sidecar_iface)
+{
+  TpBaseConnection *base_conn = TP_BASE_CONNECTION (conn);
+
+  return g_strdelimit (
+      g_strdup_printf ("%s/Sidecar/%s", base_conn->object_path, sidecar_iface),
+      ".", '/');
+}
+
+static gchar *
+connection_install_sidecar (
+    SalutConnection *conn,
+    SalutSidecar *sidecar,
+    const gchar *sidecar_iface)
+{
+  SalutConnectionPrivate *priv = conn->priv;
+  TpDBusDaemon *bus = tp_base_connection_get_dbus_daemon (
+      (TpBaseConnection *) conn);
+  gchar *path = make_sidecar_path (conn, sidecar_iface);
+
+  tp_dbus_daemon_register_object (bus, path, G_OBJECT (sidecar));
+  g_hash_table_insert (priv->sidecars, g_strdup (sidecar_iface),
+      g_object_ref (sidecar));
+
+  return path;
+}
+
+typedef struct {
+    SalutConnection *conn;
+    gchar *sidecar_iface;
+} Grr;
+
+static Grr *
+grr_new (
+    SalutConnection *conn,
+    const gchar *sidecar_iface)
+{
+  Grr *grr = g_slice_new (Grr);
+
+  grr->conn = g_object_ref (conn);
+  grr->sidecar_iface = g_strdup (sidecar_iface);
+
+  return grr;
+}
+
+static void
+grr_free (Grr *grr)
+{
+  g_object_unref (grr->conn);
+  g_free (grr->sidecar_iface);
+
+  g_slice_free (Grr, grr);
+}
+
+static void
+create_sidecar_cb (
+    GObject *loader_obj,
+    GAsyncResult *result,
+    gpointer user_data)
+{
+  SalutPluginLoader *loader = SALUT_PLUGIN_LOADER (loader_obj);
+  Grr *ctx = user_data;
+  SalutConnection *conn = ctx->conn;
+  SalutConnectionPrivate *priv = conn->priv;
+  const gchar *sidecar_iface = ctx->sidecar_iface;
+  SalutSidecar *sidecar;
+  GList *contexts;
+  GError *error = NULL;
+
+  sidecar = salut_plugin_loader_create_sidecar_finish (loader, result, &error);
+  contexts = g_hash_table_lookup (priv->pending_sidecars, sidecar_iface);
+
+  if (contexts == NULL)
+    {
+      /* We never use the empty list as a value in pending_sidecars, so this
+       * must mean we've disconnected and already returned. Jettison the
+       * sidecar!
+       */
+      DEBUG ("creating sidecar %s %s after connection closed; jettisoning!",
+          sidecar_iface, (sidecar != NULL ? "succeeded" : "failed"));
+      goto out;
+    }
+
+  if (sidecar != NULL)
+    {
+      const gchar *actual_iface = salut_sidecar_get_interface (sidecar);
+
+      if (tp_strdiff (ctx->sidecar_iface, actual_iface))
+        {
+          /* TODO: maybe this lives in the loader? It knows what the plugin is
+           * called. */
+          g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
+              "A buggy plugin created a %s sidecar when asked to create %s",
+              actual_iface, ctx->sidecar_iface);
+        }
+    }
+  else /* sidecar == NULL */
+    {
+      /* If creating the sidecar failed, 'error' should have been set */
+      g_return_if_fail (error != NULL);
+    }
+
+  if (error == NULL)
+    {
+      gchar *path = connection_install_sidecar (ctx->conn, sidecar,
+          ctx->sidecar_iface);
+      GHashTable *props = salut_sidecar_get_immutable_properties (sidecar);
+      GList *l;
+
+      for (l = contexts; l != NULL; l = l->next)
+        salut_svc_connection_future_return_from_ensure_sidecar (l->data,
+            path, props);
+
+      g_hash_table_unref (props);
+      g_free (path);
+    }
+  else
+    {
+      g_list_foreach (contexts, (GFunc) dbus_g_method_return_error, error);
+    }
+
+  g_hash_table_remove (ctx->conn->priv->pending_sidecars, ctx->sidecar_iface);
+
+out:
+  tp_clear_object (&sidecar);
+  g_clear_error (&error);
+
+  grr_free (ctx);
+}
+
+static void
+salut_connection_ensure_sidecar (
+    SalutSvcConnectionFUTURE *iface,
+    const gchar *sidecar_iface,
+    DBusGMethodInvocation *context)
+{
+  SalutConnection *conn = SALUT_CONNECTION (iface);
+  SalutConnectionPrivate *priv = conn->priv;
+  TpBaseConnection *base_conn = TP_BASE_CONNECTION (conn);
+  SalutSidecar *sidecar;
+  gpointer key, value;
+  GError *error = NULL;
+
+  if (base_conn->status == TP_CONNECTION_STATUS_DISCONNECTED)
+    {
+      GError e = { TP_ERRORS, TP_ERROR_DISCONNECTED,
+          "This connection has already disconnected" };
+
+      DEBUG ("already disconnected, declining request for %s", sidecar_iface);
+      dbus_g_method_return_error (context, &e);
+      return;
+    }
+
+  if (!tp_dbus_check_valid_interface_name (sidecar_iface, &error))
+    {
+      error->domain = TP_ERRORS;
+      error->code = TP_ERROR_INVALID_ARGUMENT;
+      DEBUG ("%s is malformed: %s", sidecar_iface, error->message);
+      dbus_g_method_return_error (context, error);
+      g_clear_error (&error);
+      return;
+    }
+
+  sidecar = g_hash_table_lookup (priv->sidecars, sidecar_iface);
+
+  if (sidecar != NULL)
+    {
+      gchar *path = make_sidecar_path (conn, sidecar_iface);
+      GHashTable *props = salut_sidecar_get_immutable_properties (sidecar);
+
+      DEBUG ("sidecar %s already exists at %s", sidecar_iface, path);
+      salut_svc_connection_future_return_from_ensure_sidecar (context, path,
+          props);
+
+      g_free (path);
+      g_hash_table_unref (props);
+      return;
+    }
+
+  if (g_hash_table_lookup_extended (priv->pending_sidecars, sidecar_iface,
+          &key, &value))
+    {
+      GList *contexts = value;
+
+      DEBUG ("already awaiting %s, joining a queue of %u", sidecar_iface,
+          g_list_length (contexts));
+
+      contexts = g_list_prepend (contexts, context);
+      g_hash_table_steal (priv->pending_sidecars, key);
+      g_hash_table_insert (priv->pending_sidecars, key, contexts);
+      return;
+    }
+
+  DEBUG ("enqueuing first request for %s", sidecar_iface);
+  g_hash_table_insert (priv->pending_sidecars, g_strdup (sidecar_iface),
+      g_list_prepend (NULL, context));
+
+  if (base_conn->status == TP_CONNECTION_STATUS_CONNECTED)
+    {
+      SalutPluginLoader *loader = salut_plugin_loader_dup ();
+
+      DEBUG ("requesting %s from the plugin loader", sidecar_iface);
+      salut_plugin_loader_create_sidecar_async (loader, sidecar_iface, conn,
+          conn->session, create_sidecar_cb, grr_new (conn, sidecar_iface));
+      g_object_unref (loader);
+    }
+  else
+    {
+      DEBUG ("not yet connected; waiting.");
+    }
+}
+
+static void
+sidecars_conn_status_changed_cb (
+    SalutConnection *conn,
+    guint status,
+    guint reason,
+    gpointer unused)
+{
+  SalutConnectionPrivate *priv = conn->priv;
+  TpDBusDaemon *bus = tp_base_connection_get_dbus_daemon (
+      (TpBaseConnection *) conn);
+  GHashTableIter iter;
+  gpointer key, value;
+
+  if (status == TP_CONNECTION_STATUS_DISCONNECTED)
+    {
+      g_hash_table_iter_init (&iter, priv->sidecars);
+
+      while (g_hash_table_iter_next (&iter, NULL, &value))
+        {
+          DEBUG ("removing %s from the bus", salut_sidecar_get_interface (value));
+          tp_dbus_daemon_unregister_object (bus, G_OBJECT (value));
+        }
+
+      g_hash_table_iter_init (&iter, priv->pending_sidecars);
+
+      while (g_hash_table_iter_next (&iter, &key, &value))
+        {
+          const gchar *sidecar_iface = key;
+          GList *contexts = value;
+          GError *error = g_error_new (TP_ERRORS, TP_ERROR_CANCELLED,
+              "Disconnected before %s could be created", sidecar_iface);
+
+          DEBUG ("failing all %u requests for %s", g_list_length (contexts),
+              sidecar_iface);
+          g_list_foreach (contexts, (GFunc) dbus_g_method_return_error, error);
+          g_error_free (error);
+        }
+
+      g_hash_table_remove_all (priv->sidecars);
+      g_hash_table_remove_all (priv->pending_sidecars);
+    }
+  else if (status == TP_CONNECTION_STATUS_CONNECTED)
+    {
+      SalutPluginLoader *loader = salut_plugin_loader_dup ();
+
+      DEBUG ("connected; requesting sidecars from plugins");
+      g_hash_table_iter_init (&iter, priv->pending_sidecars);
+
+      while (g_hash_table_iter_next (&iter, &key, NULL))
+        {
+          const gchar *sidecar_iface = key;
+
+          DEBUG ("requesting %s from the plugin loader", sidecar_iface);
+          salut_plugin_loader_create_sidecar_async (loader, sidecar_iface, conn,
+              conn->session, create_sidecar_cb, grr_new (conn, sidecar_iface));
+        }
+
+      g_object_unref (loader);
+    }
+}
+
+static void
+salut_conn_future_iface_init (gpointer g_iface,
+    gpointer iface_data)
+{
+  SalutSvcConnectionFUTUREClass *klass = g_iface;
+
+#define IMPLEMENT(x) \
+    salut_svc_connection_future_implement_##x (\
+    klass, salut_connection_##x)
+  IMPLEMENT(ensure_sidecar);
+#undef IMPLEMENT
+}
+
+WockySession *
+salut_connection_get_session (SalutConnection *connection)
+{
+  g_return_val_if_fail (SALUT_IS_CONNECTION (connection), NULL);
+
+  return connection->session;
+}
+
+const gchar *
+salut_connection_get_name (SalutConnection *connection)
+{
+  g_return_val_if_fail (SALUT_IS_CONNECTION (connection), NULL);
+
+  return connection->name;
+}