Codebase list telepathy-idle / e1291f0
Port to TLS handling code to work in Idle Instead of server-tls-manager being a Wocky TLS manager add async API to start the certificate verification on request and use a GTlsCertificate to get the needed certificate information instead of WockyTLSsession. Sjoerd Simons 11 years ago
7 changed file(s) with 126 addition(s) and 242 deletion(s). Raw diff Collapse all Expand all
+6
-0
src/Makefile.am less more
3737 idle-server-connection.h \
3838 idle-text.h \
3939 idle-text.c \
40 server-tls-channel.c \
41 server-tls-channel.h \
42 server-tls-manager.c \
43 server-tls-manager.h \
44 tls-certificate.c \
45 tls-certificate.h \
4046 $(NULL)
4147
4248 nodist_libidle_convenience_la_SOURCES = \
+1
-0
src/idle-debug.c less more
3333 {"network", IDLE_DEBUG_NETWORK},
3434 {"parser", IDLE_DEBUG_PARSER},
3535 {"text", IDLE_DEBUG_TEXT},
36 {"tls", IDLE_DEBUG_TLS},
3637 {NULL, 0}
3738 };
3839
+1
-0
src/idle-debug.h less more
3030 IDLE_DEBUG_PARSER = (1 << 5),
3131 IDLE_DEBUG_TEXT = (1 << 6),
3232 IDLE_DEBUG_ROOMLIST = (1 << 7),
33 IDLE_DEBUG_TLS = (1 << 8),
3334 } IdleDebugFlags;
3435
3536 void idle_debug_init (void);
+43
-47
src/server-tls-channel.c less more
2121
2222 #include "server-tls-channel.h"
2323
24 #include <gio/gio.h>
2425 #include <telepathy-glib/telepathy-glib.h>
2526 #include <telepathy-glib/telepathy-glib-dbus.h>
2627
27 #include <wocky/wocky.h>
28
29 #define DEBUG_FLAG IDLE_DEBUG_TLS
30 #include "debug.h"
31 #include "connection.h"
28 #define IDLE_DEBUG_FLAG IDLE_DEBUG_TLS
29 #include "idle-debug.h"
3230 #include "tls-certificate.h"
3331
3432 G_DEFINE_TYPE_WITH_CODE (IdleServerTLSChannel, idle_server_tls_channel,
4543 PROP_REFERENCE_IDENTITIES,
4644
4745 /* not exported */
48 PROP_TLS_SESSION,
46 PROP_CERTIFICATE,
4947
5048 NUM_PROPERTIES
5149 };
5250
5351 struct _IdleServerTLSChannelPrivate {
54 WockyTLSSession *tls_session;
52 GTlsCertificate *certificate;
5553
5654 IdleTLSCertificate *server_cert;
5755 gchar *server_cert_path;
8078 case PROP_REFERENCE_IDENTITIES:
8179 g_value_set_boxed (value, self->priv->reference_identities);
8280 break;
83 case PROP_TLS_SESSION:
84 g_value_set_object (value, self->priv->tls_session);
81 case PROP_CERTIFICATE:
82 g_value_set_object (value, self->priv->certificate);
8583 break;
8684 default:
8785 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
9997
10098 switch (property_id)
10199 {
102 case PROP_TLS_SESSION:
103 self->priv->tls_session = g_value_dup_object (value);
100 case PROP_CERTIFICATE:
101 self->priv->certificate = g_value_dup_object (value);
104102 break;
105103 case PROP_HOSTNAME:
106104 self->priv->hostname = g_value_dup_string (value);
119117 {
120118 IdleServerTLSChannel *self = IDLE_SERVER_TLS_CHANNEL (object);
121119
122 DEBUG ("Finalize TLS channel");
120 IDLE_DEBUG ("Finalize TLS channel");
123121
124122 g_free (self->priv->server_cert_path);
125123 g_free (self->priv->hostname);
136134 if (self->priv->dispose_has_run)
137135 return;
138136
139 DEBUG ("Dispose TLS channel");
137 IDLE_DEBUG ("Dispose TLS channel");
140138
141139 self->priv->dispose_has_run = TRUE;
142140
143141 tp_clear_object (&self->priv->server_cert);
144 tp_clear_object (&self->priv->tls_session);
142 tp_clear_object (&self->priv->certificate);
145143
146144 G_OBJECT_CLASS (idle_server_tls_channel_parent_class)->dispose (object);
147145 }
148146
149 static const gchar *
150 cert_type_to_str (WockyTLSCertType type)
151 {
152 const gchar *retval = NULL;
153
154 switch (type)
155 {
156 case WOCKY_TLS_CERT_TYPE_X509:
157 retval = "x509";
158 break;
159 case WOCKY_TLS_CERT_TYPE_OPENPGP:
160 retval = "pgp";
161 break;
162 default:
163 break;
164 }
165
166 return retval;
167 }
168
169147 static void
170148 idle_server_tls_channel_constructed (GObject *object)
171149 {
172150 IdleServerTLSChannel *self = IDLE_SERVER_TLS_CHANNEL (object);
173151 TpBaseChannel *base = TP_BASE_CHANNEL (self);
174 TpBaseConnection *base_conn = tp_base_channel_get_connection (base);
175152 void (*chain_up) (GObject *) =
176153 G_OBJECT_CLASS (idle_server_tls_channel_parent_class)->constructed;
177 WockyTLSCertType cert_type;
178154 const gchar *path;
179155 gchar *cert_object_path;
180156 GPtrArray *certificates;
157 GTlsCertificate *cert;
181158
182159 if (chain_up != NULL)
183160 chain_up (object);
187164 /* create the TLS certificate object */
188165 path = tp_base_channel_get_object_path (base);
189166 cert_object_path = g_strdup_printf ("%s/TLSCertificateObject", path);
190 certificates = wocky_tls_session_get_peers_certificate (
191 self->priv->tls_session, &cert_type);
167 certificates = g_ptr_array_new ();
168
169 /* Setup the full chain */
170 cert = self->priv->certificate;
171 while (cert != NULL)
172 {
173 GByteArray *content;
174 GArray *c;
175
176 g_object_get (cert, "certificate", &content, NULL);
177 c = g_array_sized_new (TRUE, TRUE, sizeof (guchar), content->len);
178 g_array_append_vals (c, content->data, content->len);
179 g_ptr_array_add (certificates, c);
180
181 g_byte_array_unref (content);
182
183 cert = g_tls_certificate_get_issuer (cert);
184 }
192185
193186 self->priv->server_cert = g_object_new (IDLE_TYPE_TLS_CERTIFICATE,
194187 "object-path", cert_object_path,
195188 "certificate-chain-data", certificates,
196 "certificate-type", cert_type_to_str (cert_type),
197 "dbus-daemon", IDLE_CONNECTION (base_conn)->daemon,
189 "certificate-type", "x509",
190 "dbus-daemon",
191 tp_base_connection_get_dbus_daemon (
192 tp_base_channel_get_connection (TP_BASE_CHANNEL (self))),
198193 NULL);
199194 self->priv->server_cert_path = cert_object_path;
200
201 DEBUG ("Server TLS channel constructed at %s", path);
195 g_ptr_array_unref (certificates);
196
197 IDLE_DEBUG ("Server TLS channel constructed at %s", path);
202198 }
203199
204200 static void
281277 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
282278 g_object_class_install_property (oclass, PROP_REFERENCE_IDENTITIES, pspec);
283279
284 pspec = g_param_spec_object ("tls-session", "The WockyTLSSession",
285 "The WockyTLSSession object containing the TLS information",
286 WOCKY_TYPE_TLS_SESSION,
280 pspec = g_param_spec_object ("certificate", "The GTLSCertificate",
281 "The GTLSCertificate object containing the TLS information",
282 G_TYPE_TLS_CERTIFICATE,
287283 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
288 g_object_class_install_property (oclass, PROP_TLS_SESSION, pspec);
284 g_object_class_install_property (oclass, PROP_CERTIFICATE, pspec);
289285
290286 tp_dbus_properties_mixin_implement_interface (oclass,
291287 TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_TLS_CONNECTION,
296292 static void
297293 idle_server_tls_channel_close (TpBaseChannel *base)
298294 {
299 DEBUG ("Close() called on the TLS channel %p", base);
295 IDLE_DEBUG ("Close() called on the TLS channel %p", base);
300296 tp_base_channel_destroyed (base);
301297 }
302298
+59
-188
src/server-tls-manager.c less more
2323 #include <telepathy-glib/telepathy-glib.h>
2424 #include <telepathy-glib/telepathy-glib-dbus.h>
2525
26 #define DEBUG_FLAG IDLE_DEBUG_TLS
27 #include "debug.h"
28 #include "gabble/caps-channel-manager.h"
29 #include "connection.h"
26 #define IDLE_DEBUG_FLAG IDLE_DEBUG_TLS
27 #include "idle-debug.h"
28 #include "idle-connection.h"
3029 #include "server-tls-channel.h"
31 #include "util.h"
3230
3331 #include "extensions/extensions.h"
3432
35 #include <wocky/wocky.h>
36
3733 static void channel_manager_iface_init (gpointer, gpointer);
3834
3935 G_DEFINE_TYPE_WITH_CODE (IdleServerTLSManager, idle_server_tls_manager,
40 WOCKY_TYPE_TLS_HANDLER,
36 G_TYPE_OBJECT,
4137 G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_MANAGER,
42 channel_manager_iface_init);
43 G_IMPLEMENT_INTERFACE (IDLE_TYPE_CAPS_CHANNEL_MANAGER,
44 NULL));
38 channel_manager_iface_init));
4539
4640 enum {
4741 PROP_CONNECTION = 1,
48 PROP_INTERACTIVE_TLS,
4942 NUM_PROPERTIES
5043 };
5144
5245 struct _IdleServerTLSManagerPrivate {
5346 /* Properties */
5447 IdleConnection *connection;
55 gboolean interactive_tls;
5648
5749 /* Current operation data */
58 gchar *peername;
59 GStrv reference_identities;
60 WockyTLSSession *tls_session;
6150 IdleServerTLSChannel *channel;
6251 GSimpleAsyncResult *async_result;
6352
8372 case PROP_CONNECTION:
8473 g_value_set_object (value, self->priv->connection);
8574 break;
86 case PROP_INTERACTIVE_TLS:
87 g_value_set_boolean (value, self->priv->interactive_tls);
75 default:
76 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
77 break;
78 }
79 }
80
81 static void
82 idle_server_tls_manager_set_property (GObject *object,
83 guint property_id,
84 const GValue *value,
85 GParamSpec *pspec)
86 {
87 IdleServerTLSManager *self = IDLE_SERVER_TLS_MANAGER (object);
88
89 switch (property_id)
90 {
91 case PROP_CONNECTION:
92 self->priv->connection = g_value_dup_object (value);
8893 break;
8994 default:
9095 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
9398 }
9499
95100 static void
96 idle_server_tls_manager_set_property (GObject *object,
97 guint property_id,
98 const GValue *value,
99 GParamSpec *pspec)
100 {
101 IdleServerTLSManager *self = IDLE_SERVER_TLS_MANAGER (object);
102
103 switch (property_id)
104 {
105 case PROP_CONNECTION:
106 self->priv->connection = g_value_dup_object (value);
107 break;
108 case PROP_INTERACTIVE_TLS:
109 self->priv->interactive_tls = g_value_get_boolean (value);
110 break;
111 default:
112 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
113 break;
114 }
115 }
116
117 static void
118101 close_all (IdleServerTLSManager *self)
119102 {
120103 GList *l;
143126 {
144127 IdleServerTLSManager *self = user_data;
145128
146 DEBUG ("Connection status changed, now %d", status);
129 IDLE_DEBUG ("Connection status changed, now %d", status);
147130
148131 if (status == TP_CONNECTION_STATUS_DISCONNECTED)
149132 {
166149 g_simple_async_result_complete (self->priv->async_result);
167150
168151 /* Reset to initial state */
169 tp_clear_pointer (&self->priv->peername, g_free);
170 tp_clear_pointer (&self->priv->reference_identities, g_strfreev);
171 g_clear_object (&self->priv->tls_session);
172152 g_clear_object (&self->priv->channel);
173153 g_clear_object (&self->priv->async_result);
174154 }
175155
176156 static void
177 verify_fallback_cb (GObject *source,
178 GAsyncResult *result,
179 gpointer user_data)
180 {
181 IdleServerTLSManager *self = (IdleServerTLSManager *) source;
182 GError *error = NULL;
183
184 if (!chainup->verify_finish_func (WOCKY_TLS_HANDLER (self), result, &error))
185 g_simple_async_result_take_error (self->priv->async_result, error);
186
187 complete_verify (self);
188 }
189
190 static void
191157 server_tls_channel_closed_cb (IdleServerTLSChannel *channel,
192158 gpointer user_data)
193159 {
194160 IdleServerTLSManager *self = user_data;
195161
196 DEBUG ("Server TLS channel closed.");
162 IDLE_DEBUG ("Server TLS channel closed.");
197163
198164 if (channel == self->priv->channel)
199165 {
200 /* fallback to the old-style non interactive TLS verification */
201 DEBUG ("Channel closed, but unhandled, falling back...");
202
203 chainup->verify_async_func (WOCKY_TLS_HANDLER (self),
204 self->priv->tls_session, self->priv->peername,
205 self->priv->reference_identities, verify_fallback_cb, NULL);
206
207 self->priv->channel = NULL;
166 complete_verify (self);
208167 }
209168 else
210169 {
239198 {
240199 IdleServerTLSManager *self = user_data;
241200
242 DEBUG ("TLS certificate accepted");
201 IDLE_DEBUG ("TLS certificate accepted");
243202
244203 complete_verify (self);
245204 }
251210 {
252211 IdleServerTLSManager *self = user_data;
253212
254 DEBUG ("TLS certificate rejected with rejections %p, length %u.",
213 IDLE_DEBUG ("TLS certificate rejected with rejections %p, length %u.",
255214 rejections, rejections->len);
256215
257216 g_simple_async_result_set_error (self->priv->async_result,
260219 complete_verify (self);
261220 }
262221
263 static void
264 extend_string_ptr_array (GPtrArray *array,
265 GStrv new_elements)
266 {
267 gint i;
268
269 if (new_elements != NULL)
270 {
271 for (i = 0; new_elements[i] != NULL; i++)
272 {
273 if (!tp_str_empty (new_elements[i]))
274 g_ptr_array_add (array, g_strdup (new_elements[i]));
275 }
276 }
277 }
278
279 static void
280 fill_reference_identities (IdleServerTLSManager *self,
222 void
223 idle_server_tls_manager_verify_async (IdleServerTLSManager *self,
224 GTlsCertificate *certificate,
281225 const gchar *peername,
282 GStrv original_extra_identities)
283 {
284 GPtrArray *identities;
285 gchar *connect_server = NULL;
286 gchar *explicit_server = NULL;
287 GStrv extra_certificate_identities = NULL;
288
289 g_return_if_fail (self->priv->reference_identities == NULL);
290
291 g_object_get (self->priv->connection,
292 "connect-server", &connect_server,
293 "explicit-server", &explicit_server,
294 "extra-certificate-identities", &extra_certificate_identities,
295 NULL);
296
297 identities = g_ptr_array_new ();
298
299 /* The peer name, i.e, the domain part of the JID */
300 g_ptr_array_add (identities, g_strdup (peername));
301
302 /* The extra identities that the caller of verify_async() passed */
303 extend_string_ptr_array (identities, original_extra_identities);
304
305 /* The explicitly overridden server (if in use) */
306 if (!tp_str_empty (explicit_server) &&
307 !tp_strdiff (connect_server, explicit_server))
308 {
309 g_ptr_array_add (identities, g_strdup (explicit_server));
310 }
311
312 /* Extra identities added to the account as a result of user choices */
313 extend_string_ptr_array (identities, extra_certificate_identities);
314
315 /* Null terminate, since this is a gchar** */
316 g_ptr_array_add (identities, NULL);
317
318 self->priv->reference_identities = (GStrv) g_ptr_array_free (identities,
319 FALSE);
320
321 g_strfreev (extra_certificate_identities);
322 g_free (explicit_server);
323 g_free (connect_server);
324 }
325
326 static void
327 idle_server_tls_manager_verify_async (WockyTLSHandler *handler,
328 WockyTLSSession *tls_session,
329 const gchar *peername,
330 GStrv extra_identities,
331226 GAsyncReadyCallback callback,
332227 gpointer user_data)
333228 {
334 IdleServerTLSManager *self = IDLE_SERVER_TLS_MANAGER (handler);
335 IdleTLSCertificate *certificate;
229 IdleTLSCertificate *cert;
336230 GSimpleAsyncResult *result;
231 const gchar *identities[] = { peername, NULL };
337232
338233 g_return_if_fail (self->priv->async_result == NULL);
339234
340 DEBUG ("verify_async() called on the IdleServerTLSManager.");
235 IDLE_DEBUG ("verify_async() called on the IdleServerTLSManager.");
341236
342237 result = g_simple_async_result_new (G_OBJECT (self),
343238 callback, user_data, idle_server_tls_manager_verify_async);
344239
345240 if (self->priv->connection == NULL)
346241 {
347 DEBUG ("connection already went away; failing immediately");
242 IDLE_DEBUG ("connection already went away; failing immediately");
348243 g_simple_async_result_set_error (result, TP_ERROR, TP_ERROR_CANCELLED,
349244 "The Telepathy connection has already been disconnected");
350245 g_simple_async_result_complete_in_idle (result);
354249
355250 self->priv->async_result = result;
356251
357 fill_reference_identities (self, peername, extra_identities);
358
359 if (!self->priv->interactive_tls)
360 {
361 DEBUG ("ignore-ssl-errors is set, fallback to non-interactive "
362 "verification.");
363
364 chainup->verify_async_func (WOCKY_TLS_HANDLER (self), tls_session,
365 peername, self->priv->reference_identities, verify_fallback_cb, NULL);
366
367 return;
368 }
369
370 self->priv->tls_session = g_object_ref (tls_session);
371 self->priv->peername = g_strdup (peername);
372
373252 self->priv->channel = g_object_new (IDLE_TYPE_SERVER_TLS_CHANNEL,
374253 "connection", self->priv->connection,
375 "tls-session", tls_session,
254 "certificate", certificate,
376255 "hostname", peername,
377 "reference-identities", self->priv->reference_identities,
256 "reference-identities", identities,
378257 NULL);
379258
380259 g_signal_connect (self->priv->channel, "closed",
381260 G_CALLBACK (server_tls_channel_closed_cb), self);
382261
383 certificate = idle_server_tls_channel_get_certificate (self->priv->channel);
384
385 g_signal_connect (certificate, "accepted",
262 cert = idle_server_tls_channel_get_certificate (self->priv->channel);
263
264 g_signal_connect (cert, "accepted",
386265 G_CALLBACK (tls_certificate_accepted_cb), self);
387 g_signal_connect (certificate, "rejected",
266 g_signal_connect (cert, "rejected",
388267 G_CALLBACK (tls_certificate_rejected_cb), self);
389268
390269 /* emit NewChannel on the ChannelManager iface */
392271 (TpExportableChannel *) self->priv->channel, NULL);
393272 }
394273
395 static gboolean
396 idle_server_tls_manager_verify_finish (WockyTLSHandler *self,
274 gboolean
275 idle_server_tls_manager_verify_finish (IdleServerTLSManager *self,
397276 GAsyncResult *result,
398277 GError **error)
399278 {
400 wocky_implement_finish_void (self, idle_server_tls_manager_verify_async);
279 if (g_simple_async_result_propagate_error (
280 G_SIMPLE_ASYNC_RESULT (result), error))
281 return FALSE;
282
283 g_return_val_if_fail (g_simple_async_result_is_valid (result,
284 G_OBJECT(self), idle_server_tls_manager_verify_async), FALSE);
285 return TRUE;
401286 }
402287
403288 static void
412297 {
413298 IdleServerTLSManager *self = IDLE_SERVER_TLS_MANAGER (object);
414299
415 DEBUG ("%p", self);
300 IDLE_DEBUG ("%p", self);
416301
417302 if (self->priv->dispose_has_run)
418303 return;
419304
420305 self->priv->dispose_has_run = TRUE;
421306
422 tp_clear_object (&self->priv->tls_session);
423307 tp_clear_object (&self->priv->connection);
424308
425309 G_OBJECT_CLASS (idle_server_tls_manager_parent_class)->dispose (object);
430314 {
431315 IdleServerTLSManager *self = IDLE_SERVER_TLS_MANAGER (object);
432316
433 DEBUG ("%p", self);
317 IDLE_DEBUG ("%p", self);
434318
435319 close_all (self);
436
437 g_free (self->priv->peername);
438 g_strfreev (self->priv->reference_identities);
439320
440321 G_OBJECT_CLASS (idle_server_tls_manager_parent_class)->finalize (object);
441322 }
450331 if (chain_up != NULL)
451332 chain_up (object);
452333
453 DEBUG ("Server TLS Manager constructed");
454
455 idle_signal_connect_weak (self->priv->connection, "status-changed",
456 G_CALLBACK (connection_status_changed_cb), object);
334 IDLE_DEBUG ("Server TLS Manager constructed");
335
336 tp_g_signal_connect_object (self->priv->connection, "status-changed",
337 G_CALLBACK (connection_status_changed_cb), object, 0);
457338 }
458339
459340 static void
460341 idle_server_tls_manager_class_init (IdleServerTLSManagerClass *klass)
461342 {
462343 GObjectClass *oclass = G_OBJECT_CLASS (klass);
463 WockyTLSHandlerClass *hclass = WOCKY_TLS_HANDLER_CLASS (klass);
464344 GParamSpec *pspec;
465345
466346 g_type_class_add_private (klass, sizeof (IdleServerTLSManagerPrivate));
471351 oclass->set_property = idle_server_tls_manager_set_property;
472352 oclass->get_property = idle_server_tls_manager_get_property;
473353
474 hclass->verify_async_func = idle_server_tls_manager_verify_async;
475 hclass->verify_finish_func = idle_server_tls_manager_verify_finish;
476
477 pspec = g_param_spec_object ("connection", "IdleConnection object",
478 "Idle connection object that owns this manager.",
479 IDLE_TYPE_CONNECTION,
354 pspec = g_param_spec_object ("connection", "Base connection object",
355 "base connection object that owns this manager.",
356 TP_TYPE_BASE_CONNECTION,
480357 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
481358 g_object_class_install_property (oclass, PROP_CONNECTION, pspec);
482
483 pspec = g_param_spec_boolean ("interactive-tls", "Interactive TLS setting",
484 "Whether interactive TLS certificate verification is enabled.",
485 FALSE,
486 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
487 g_object_class_install_property (oclass, PROP_INTERACTIVE_TLS, pspec);
488359 }
489360
490361 static void
+12
-3
src/server-tls-manager.h less more
2121 #define __IDLE_SERVER_TLS_MANAGER_H__
2222
2323 #include <glib-object.h>
24 #include <wocky/wocky.h>
2524 #include <telepathy-glib/telepathy-glib.h>
2625
2726 #include "extensions/extensions.h"
3332 typedef struct _IdleServerTLSManagerPrivate IdleServerTLSManagerPrivate;
3433
3534 struct _IdleServerTLSManagerClass {
36 WockyTLSHandlerClass parent_class;
35 GObjectClass parent_class;
3736 };
3837
3938 struct _IdleServerTLSManager {
40 WockyTLSHandler parent;
39 GObject parent;
4140 IdleServerTLSManagerPrivate *priv;
4241 };
4342
6867 GHashTable **details,
6968 TpConnectionStatusReason *reason);
7069
70 void idle_server_tls_manager_verify_async (IdleServerTLSManager *self,
71 GTlsCertificate *certificate,
72 const gchar *peername,
73 GAsyncReadyCallback callback,
74 gpointer user_data);
75
76 gboolean idle_server_tls_manager_verify_finish (IdleServerTLSManager *self,
77 GAsyncResult *result,
78 GError **error);
79
7180 G_END_DECLS
7281
7382 #endif /* #ifndef __IDLE_SERVER_TLS_MANAGER_H__ */
+4
-4
src/tls-certificate.c less more
2323 #include <telepathy-glib/telepathy-glib.h>
2424 #include <telepathy-glib/telepathy-glib-dbus.h>
2525
26 #define DEBUG_FLAG IDLE_DEBUG_TLS
27 #include "debug.h"
26 #define IDLE_DEBUG_FLAG IDLE_DEBUG_TLS
27 #include "idle-debug.h"
2828
2929 static void
3030 tls_certificate_iface_init (gpointer g_iface, gpointer iface_data);
259259 {
260260 IdleTLSCertificate *self = IDLE_TLS_CERTIFICATE (cert);
261261
262 DEBUG ("Accept() called on the TLS certificate; current state %u",
262 IDLE_DEBUG ("Accept() called on the TLS certificate; current state %u",
263263 self->priv->cert_state);
264264
265265 if (self->priv->cert_state != TP_TLS_CERTIFICATE_STATE_PENDING)
288288 {
289289 IdleTLSCertificate *self = IDLE_TLS_CERTIFICATE (cert);
290290
291 DEBUG ("Reject() called on the TLS certificate with rejections %p, "
291 IDLE_DEBUG ("Reject() called on the TLS certificate with rejections %p, "
292292 "length %u; current state %u", rejections, rejections->len,
293293 self->priv->cert_state);
294294