2 * empathy-auth-factory.c - Source for EmpathyAuthFactory
3 * Copyright (C) 2010 Collabora Ltd.
4 * @author Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
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.
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.
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
21 #include "empathy-auth-factory.h"
23 #include <telepathy-glib/interfaces.h>
24 #include <telepathy-glib/simple-handler.h>
25 #include <telepathy-glib/util.h>
27 #define DEBUG_FLAG EMPATHY_DEBUG_TLS
28 #include "empathy-debug.h"
29 #include "empathy-server-tls-handler.h"
30 #include "empathy-utils.h"
32 #include "extensions/extensions.h"
34 G_DEFINE_TYPE (EmpathyAuthFactory, empathy_auth_factory, G_TYPE_OBJECT);
37 TpBaseClient *handler;
40 } EmpathyAuthFactoryPriv;
43 NEW_SERVER_TLS_HANDLER,
47 static guint signals[LAST_SIGNAL] = { 0, };
49 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAuthFactory)
51 static EmpathyAuthFactory *auth_factory_singleton = NULL;
54 TpHandleChannelsContext *context;
55 EmpathyAuthFactory *self;
59 handler_context_data_free (HandlerContextData *data)
61 tp_clear_object (&data->self);
62 tp_clear_object (&data->context);
64 g_slice_free (HandlerContextData, data);
67 static HandlerContextData *
68 handler_context_data_new (EmpathyAuthFactory *self,
69 TpHandleChannelsContext *context)
71 HandlerContextData *data;
73 data = g_slice_new0 (HandlerContextData);
74 data->self = g_object_ref (self);
75 data->context = g_object_ref (context);
81 server_tls_handler_ready_cb (GObject *source,
85 EmpathyServerTLSHandler *handler;
87 EmpathyAuthFactoryPriv *priv;
88 HandlerContextData *data = user_data;
90 priv = GET_PRIV (data->self);
91 handler = empathy_server_tls_handler_new_finish (res, &error);
95 DEBUG ("Failed to create a server TLS handler; error %s",
97 tp_handle_channels_context_fail (data->context, error);
103 tp_handle_channels_context_accept (data->context);
104 g_signal_emit (data->self, signals[NEW_SERVER_TLS_HANDLER], 0,
107 g_object_unref (handler);
110 handler_context_data_free (data);
114 handle_channels_cb (TpSimpleHandler *handler,
116 TpConnection *connection,
118 GList *requests_satisfied,
119 gint64 user_action_time,
120 TpHandleChannelsContext *context,
124 const GError *dbus_error;
125 GError *error = NULL;
126 EmpathyAuthFactory *self = user_data;
127 HandlerContextData *data;
129 DEBUG ("Handle TLS carrier channels.");
131 /* there can't be more than one ServerTLSConnection channels
132 * at the same time, for the same connection/account.
134 if (g_list_length (channels) != 1)
136 g_set_error_literal (&error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
137 "Can't handle more than one ServerTLSConnection channel "
138 "for the same connection.");
143 channel = channels->data;
145 if (tp_channel_get_channel_type_id (channel) !=
146 EMP_IFACE_QUARK_CHANNEL_TYPE_SERVER_TLS_CONNECTION)
148 g_set_error (&error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
149 "Can only handle ServerTLSConnection channels, this was a %s "
150 "channel", tp_channel_get_channel_type (channel));
155 dbus_error = tp_proxy_get_invalidated (channel);
157 if (dbus_error != NULL)
159 error = g_error_copy (dbus_error);
163 /* create a handler */
164 data = handler_context_data_new (self, context);
165 tp_handle_channels_context_delay (context);
166 empathy_server_tls_handler_new_async (channel, server_tls_handler_ready_cb,
172 tp_handle_channels_context_fail (context, error);
173 g_clear_error (&error);
177 empathy_auth_factory_constructor (GType type,
179 GObjectConstructParam *params)
183 if (auth_factory_singleton != NULL)
185 retval = g_object_ref (auth_factory_singleton);
189 retval = G_OBJECT_CLASS (empathy_auth_factory_parent_class)->constructor
190 (type, n_params, params);
192 auth_factory_singleton = EMPATHY_AUTH_FACTORY (retval);
193 g_object_add_weak_pointer (retval, (gpointer *) &auth_factory_singleton);
200 empathy_auth_factory_init (EmpathyAuthFactory *self)
202 EmpathyAuthFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
203 EMPATHY_TYPE_AUTH_FACTORY, EmpathyAuthFactoryPriv);
205 GError *error = NULL;
209 bus = tp_dbus_daemon_dup (&error);
212 g_critical ("Failed to get TpDBusDaemon: %s", error->message);
213 g_error_free (error);
217 priv->handler = tp_simple_handler_new (bus, FALSE, FALSE, "Empathy.Auth",
218 FALSE, handle_channels_cb, self, NULL);
220 tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
221 TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
222 EMP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION,
223 TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
224 TP_HANDLE_TYPE_NONE, NULL));
226 g_object_unref (bus);
230 empathy_auth_factory_dispose (GObject *object)
232 EmpathyAuthFactoryPriv *priv = GET_PRIV (object);
234 if (priv->dispose_run)
237 priv->dispose_run = TRUE;
239 tp_clear_object (&priv->handler);
241 G_OBJECT_CLASS (empathy_auth_factory_parent_class)->dispose (object);
245 empathy_auth_factory_class_init (EmpathyAuthFactoryClass *klass)
247 GObjectClass *oclass = G_OBJECT_CLASS (klass);
249 oclass->constructor = empathy_auth_factory_constructor;
250 oclass->dispose = empathy_auth_factory_dispose;
252 g_type_class_add_private (klass, sizeof (EmpathyAuthFactoryPriv));
254 signals[NEW_SERVER_TLS_HANDLER] =
255 g_signal_new ("new-server-tls-handler",
256 G_TYPE_FROM_CLASS (klass),
257 G_SIGNAL_RUN_LAST, 0,
259 g_cclosure_marshal_VOID__OBJECT,
261 1, EMPATHY_TYPE_SERVER_TLS_HANDLER);
265 empathy_auth_factory_dup_singleton (void)
267 return g_object_new (EMPATHY_TYPE_AUTH_FACTORY, NULL);
271 empathy_auth_factory_register (EmpathyAuthFactory *self,
274 EmpathyAuthFactoryPriv *priv = GET_PRIV (self);
276 return tp_base_client_register (priv->handler, error);