libempathy/empathy-auth-factory.c

   1 /*
   2  * empathy-auth-factory.c - Source for EmpathyAuthFactory
   3  * Copyright (C) 2010 Collabora Ltd.
   4  * @author Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 #include "empathy-auth-factory.h"
  22
  23 #include <telepathy-glib/interfaces.h>
  24 #include <telepathy-glib/simple-handler.h>
  25
  26 #define DEBUG_FLAG EMPATHY_DEBUG_TLS
  27 #include "empathy-debug.h"
  28 #include "empathy-server-tls-handler.h"
  29 #include "empathy-utils.h"
  30
  31 #include "extensions/extensions.h"
  32
  33 G_DEFINE_TYPE (EmpathyAuthFactory, empathy_auth_factory, G_TYPE_OBJECT);
  34
  35 typedef struct {
  36   TpBaseClient *handler;
  37 } EmpathyAuthFactoryPriv;
  38
  39 enum {
  40   NEW_SERVER_TLS_HANDLER,
  41   LAST_SIGNAL,
  42 };
  43
  44 static guint signals[LAST_SIGNAL] = { 0, };
  45
  46 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAuthFactory)
  47
  48 static EmpathyAuthFactory *auth_factory_singleton = NULL;
  49
  50 static void
  51 server_tls_handler_ready_cb (GObject *source,
  52     GAsyncResult *res,
  53     gpointer user_data)
  54 {
  55   EmpathyAuthFactory *self = user_data;
  56   GError *error = NULL;
  57   EmpathyServerTLSHandler *handler;
  58
  59   handler = empathy_server_tls_handler_new_finish (res, &error);
  60
  61   if (error != NULL)
  62     {
  63       DEBUG ("Failed to create a server TLS handler; error %s",
  64           error->message);
  65       g_error_free (error);
  66     }
  67   else
  68     {
  69       g_signal_emit (self, signals[NEW_SERVER_TLS_HANDLER], 0,
  70           handler);
  71     }
  72 }
  73
  74 static void
  75 handle_channels_cb (TpSimpleHandler *handler,
  76     TpAccount *account,
  77     TpConnection *connection,
  78     GList *channels,
  79     GList *requests_satisfied,
  80     gint64 user_action_time,
  81     TpHandleChannelsContext *context,
  82     gpointer user_data)
  83 {
  84   TpChannel *channel;
  85   EmpathyAuthFactory *self = user_data;
  86
  87   DEBUG ("Handle TLS carrier channels.");
  88
  89   /* there can't be more than one ServerTLSConnection channels
  90    * at the same time, for the same connection/account.
  91    */
  92   g_assert (g_list_length (channels) == 1);
  93
  94   channel = channels->data;
  95
  96   if (tp_proxy_get_invalidated (channel) != NULL)
  97     goto out;
  98
  99   if (tp_channel_get_channel_type_id (channel) !=
 100       EMP_IFACE_QUARK_CHANNEL_TYPE_SERVER_TLS_CONNECTION)
 101     goto out;
 102
 103   /* create a handler */
 104   empathy_server_tls_handler_new_async (channel, server_tls_handler_ready_cb,
 105       self);
 106
 107  out:
 108   tp_handle_channels_context_accept (context);
 109 }
 110
 111 static GObject *
 112 empathy_auth_factory_constructor (GType type,
 113     guint n_params,
 114     GObjectConstructParam *params)
 115 {
 116   GObject *retval;
 117
 118   if (auth_factory_singleton != NULL)
 119     {
 120       retval = g_object_ref (auth_factory_singleton);
 121     }
 122   else
 123     {
 124       retval = G_OBJECT_CLASS (empathy_auth_factory_parent_class)->constructor
 125         (type, n_params, params);
 126
 127       auth_factory_singleton = EMPATHY_AUTH_FACTORY (retval);
 128       g_object_add_weak_pointer (retval, (gpointer *) &auth_factory_singleton);
 129     }
 130
 131   return retval;
 132 }
 133
 134 static void
 135 empathy_auth_factory_init (EmpathyAuthFactory *self)
 136 {
 137   EmpathyAuthFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 138       EMPATHY_TYPE_AUTH_FACTORY, EmpathyAuthFactoryPriv);
 139   TpDBusDaemon *bus;
 140   GError *error = NULL;
 141
 142   self->priv = priv;
 143
 144   bus = tp_dbus_daemon_dup (&error);
 145   if (error != NULL)
 146     {
 147       g_critical ("Failed to get TpDBusDaemon: %s", error->message);
 148       g_error_free (error);
 149       return;
 150     }
 151
 152   priv->handler = tp_simple_handler_new (bus, FALSE, FALSE, "Empathy.Auth",
 153       FALSE, handle_channels_cb, self, NULL);
 154
 155   tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
 156           TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
 157           EMP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION,
 158           TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
 159           TP_HANDLE_TYPE_NONE, NULL));
 160
 161   g_object_unref (bus);
 162 }
 163
 164 static void
 165 empathy_auth_factory_finalize (GObject *object)
 166 {
 167   EmpathyAuthFactoryPriv *priv = GET_PRIV (object);
 168
 169   if (priv->handler != NULL)
 170     g_object_unref (priv->handler);
 171
 172   G_OBJECT_CLASS (empathy_auth_factory_parent_class)->finalize (object);
 173 }
 174
 175 static void
 176 empathy_auth_factory_class_init (EmpathyAuthFactoryClass *klass)
 177 {
 178   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 179
 180   oclass->constructor = empathy_auth_factory_constructor;
 181   oclass->finalize = empathy_auth_factory_finalize;
 182
 183   g_type_class_add_private (klass, sizeof (EmpathyAuthFactoryPriv));
 184
 185   signals[NEW_SERVER_TLS_HANDLER] =
 186     g_signal_new ("new-server-tls-handler",
 187       G_TYPE_FROM_CLASS (klass),
 188       G_SIGNAL_RUN_LAST, 0,
 189       NULL, NULL,
 190       g_cclosure_marshal_VOID__OBJECT,
 191       G_TYPE_NONE,
 192       1, EMPATHY_TYPE_SERVER_TLS_HANDLER);
 193 }
 194
 195 EmpathyAuthFactory *
 196 empathy_auth_factory_dup_singleton (void)
 197 {
 198   return g_object_new (EMPATHY_TYPE_AUTH_FACTORY, NULL);
 199 }
 200
 201 gboolean
 202 empathy_auth_factory_register (EmpathyAuthFactory *self,
 203     GError **error)
 204 {
 205   EmpathyAuthFactoryPriv *priv = GET_PRIV (self);
 206
 207   return tp_base_client_register (priv->handler, error);
 208 }