src/telepathy/telepathy-tls.c

   1 /**
   2  * @file telepathy-tls.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2013 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * TLS certificate accept/reject user interaction
  23  */
  24
  25 #include <string.h>
  26
  27 #include <glib-object.h>
  28 #include <telepathy-glib/dbus-properties-mixin.h>
  29 #include <telepathy-glib/svc-channel.h>
  30 #include <telepathy-glib/svc-tls.h>
  31 #include <telepathy-glib/telepathy-glib.h>
  32
  33 #include "sipe-backend.h"
  34 #include "sipe-common.h"
  35
  36 #include "telepathy-private.h"
  37
  38 /* TLS information required for user interaction */
  39 struct _SipeTLSCertificate;
  40 struct sipe_tls_info {
  41         gchar *hostname;
  42         gchar *cert_path;
  43         GPtrArray *cert_data;
  44         GStrv reference_identities;
  45         struct _SipeTLSCertificate *certificate;
  46 };
  47
  48 /* Certificate states */
  49 #define SIPE_TLS_CERTIFICATE_PENDING  0
  50 #define SIPE_TLS_CERTIFICATE_REJECTED 1
  51 #define SIPE_TLS_CERTIFICATE_ACCEPTED 2
  52
  53 G_BEGIN_DECLS
  54 /*
  55  * TLS Manager class - data structures
  56  */
  57 typedef struct _SipeTLSManagerClass {
  58         GObjectClass parent_class;
  59 } SipeTLSManagerClass;
  60
  61 typedef struct _SipeTLSManager {
  62         GObject parent;
  63
  64         GObject *connection;
  65
  66         GSList *channels;
  67 } SipeTLSManager;
  68
  69 /*
  70  * TLS Manager class - type macros
  71  */
  72 static GType sipe_tls_manager_get_type(void);
  73 #define SIPE_TYPE_TLS_MANAGER \
  74         (sipe_tls_manager_get_type())
  75 #define SIPE_TLS_MANAGER(obj) \
  76         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_TLS_MANAGER, \
  77                                     SipeTLSManager))
  78
  79 /*
  80  * TLS Channel class - data structures
  81  */
  82 typedef struct _SipeTLSChannelClass {
  83         TpBaseChannelClass parent_class;
  84 } SipeTLSChannelClass;
  85
  86 typedef struct _SipeTLSChannel {
  87         TpBaseChannel parent;
  88
  89         const struct sipe_tls_info *tls_info;
  90
  91         GSimpleAsyncResult *result;
  92 } SipeTLSChannel;
  93
  94 /*
  95  * TLS Channel class - type macros
  96  */
  97 static GType sipe_tls_channel_get_type(void) G_GNUC_CONST;
  98 #define SIPE_TYPE_TLS_CHANNEL \
  99         (sipe_tls_channel_get_type())
 100 #define SIPE_TLS_CHANNEL(obj) \
 101         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_TLS_CHANNEL, \
 102                                     SipeTLSChannel))
 103
 104 /*
 105  * TLS Certificate class - data structures
 106  */
 107 typedef struct _SipeTLSCertificateClass {
 108         GObjectClass parent_class;
 109
 110         TpDBusPropertiesMixinClass dbus_props_class;
 111 } SipeTLSCertificateClass;
 112
 113 typedef struct _SipeTLSCertificate {
 114         GObject parent;
 115
 116         const struct sipe_tls_info *tls_info;
 117
 118         guint state;
 119 } SipeTLSCertificate;
 120
 121 /*
 122  * TLS Certificate class - type macros
 123  */
 124 static GType sipe_tls_certificate_get_type(void) G_GNUC_CONST;
 125 #define SIPE_TYPE_TLS_CERTIFICATE \
 126         (sipe_tls_certificate_get_type())
 127 #define SIPE_TLS_CERTIFICATE(obj) \
 128         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_TLS_CERTIFICATE, \
 129                                     SipeTLSCertificate))
 130 G_END_DECLS
 131
 132 /*
 133  * TLS Manager class - type definition
 134  */
 135 static void channel_manager_iface_init(gpointer, gpointer);
 136 G_DEFINE_TYPE_WITH_CODE(SipeTLSManager,
 137                         sipe_tls_manager,
 138                         G_TYPE_OBJECT,
 139                         G_IMPLEMENT_INTERFACE(TP_TYPE_CHANNEL_MANAGER,
 140                                               channel_manager_iface_init);
 141 )
 142
 143 /*
 144  * TLS Channel class - type definition
 145  */
 146 G_DEFINE_TYPE_WITH_CODE(SipeTLSChannel,
 147                         sipe_tls_channel,
 148                         TP_TYPE_BASE_CHANNEL,
 149                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CHANNEL_TYPE_SERVER_TLS_CONNECTION,
 150                                               NULL);
 151 )
 152
 153 /*
 154  * TLS Certificate class - type definition
 155  */
 156 static void tls_certificate_iface_init(gpointer, gpointer);
 157 G_DEFINE_TYPE_WITH_CODE (SipeTLSCertificate,
 158                          sipe_tls_certificate,
 159                          G_TYPE_OBJECT,
 160                          G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_AUTHENTICATION_TLS_CERTIFICATE,
 161                                                tls_certificate_iface_init);
 162                          G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_DBUS_PROPERTIES,
 163                                                tp_dbus_properties_mixin_iface_init);
 164 )
 165
 166 /*
 167  * TLS Manager class - instance methods
 168  */
 169 static void sipe_tls_manager_constructed(GObject *object)
 170 {
 171         SipeTLSManager *self        = SIPE_TLS_MANAGER(object);
 172         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_tls_manager_parent_class)->constructed;
 173
 174         if (chain_up)
 175                 chain_up(object);
 176
 177         self->channels = NULL;
 178 }
 179
 180 static void sipe_tls_manager_dispose(GObject *object)
 181 {
 182         SipeTLSManager *self        = SIPE_TLS_MANAGER(object);
 183         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_tls_manager_parent_class)->constructed;
 184
 185         tp_clear_object(&self->connection);
 186
 187         if (chain_up)
 188                 chain_up(object);
 189 }
 190
 191 static void sipe_tls_manager_finalize(GObject *object)
 192 {
 193         SipeTLSManager *self        = SIPE_TLS_MANAGER(object);
 194         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_tls_manager_parent_class)->constructed;
 195         GSList *entry               = self->channels;
 196
 197         /* close channels */
 198         while (entry) {
 199                 GSList *next = entry->next;
 200                 /* removes entry from list */
 201                 tp_base_channel_close(entry->data);
 202                 entry = next;
 203         }
 204
 205         tp_clear_object(&self->connection);
 206
 207         if (chain_up)
 208                 chain_up(object);
 209 }
 210
 211
 212 /*
 213  * TLS Manager class - type implementation
 214  */
 215 static void sipe_tls_manager_class_init(SipeTLSManagerClass *klass)
 216 {
 217         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 218
 219         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSManager::class_init");
 220
 221         object_class->constructed  = sipe_tls_manager_constructed;
 222         object_class->dispose      = sipe_tls_manager_dispose;
 223         object_class->finalize     = sipe_tls_manager_finalize;
 224 }
 225
 226 static void sipe_tls_manager_init(SIPE_UNUSED_PARAMETER SipeTLSManager *self)
 227 {
 228         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSManager::init");
 229 }
 230
 231 /*
 232  * TLS Manager class - interface implementation
 233  *
 234  * Channel Manager
 235  */
 236 static void foreach_channel(TpChannelManager *manager,
 237                             TpExportableChannelFunc func,
 238                             gpointer user_data)
 239 {
 240         SipeTLSManager *self = SIPE_TLS_MANAGER(manager);
 241
 242         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSManager::foreach_channel");
 243
 244         /* @TODO */
 245         (void)self;
 246         (void)func;
 247         (void)user_data;
 248 }
 249
 250 static void channel_manager_iface_init(gpointer g_iface,
 251                                        SIPE_UNUSED_PARAMETER gpointer iface_data)
 252 {
 253         TpChannelManagerIface *iface = g_iface;
 254
 255 #define IMPLEMENT(x, y) iface->x = y
 256         IMPLEMENT(foreach_channel,            foreach_channel);
 257         /* These channels are not requestable. */
 258         IMPLEMENT(type_foreach_channel_class, NULL);
 259         IMPLEMENT(create_channel,             NULL);
 260         IMPLEMENT(request_channel,            NULL);
 261         IMPLEMENT(ensure_channel,             NULL);
 262 #undef IMPLEMENT
 263 }
 264
 265 /* create new TLS manager object */
 266 SipeTLSManager *sipe_telepathy_tls_new(TpBaseConnection *connection)
 267 {
 268         SipeTLSManager *self = g_object_new(SIPE_TYPE_TLS_MANAGER, NULL);
 269         self->connection = g_object_ref(connection);
 270         return(self);
 271 }
 272
 273 static void channel_closed_cb(SipeTLSChannel *channel,
 274                               SipeTLSManager *self)
 275 {
 276         self->channels = g_slist_remove(self->channels, channel);
 277         tp_channel_manager_emit_channel_closed_for_object(self,
 278                                                           TP_EXPORTABLE_CHANNEL(channel));
 279         g_object_unref(channel);
 280 }
 281
 282 static void manager_new_channel(SipeTLSManager *self,
 283                                 SipeTLSChannel *channel)
 284 {
 285         self->channels = g_slist_prepend(self->channels,
 286                                          g_object_ref(channel));
 287
 288         g_signal_connect(channel,
 289                          "closed",
 290                          G_CALLBACK(channel_closed_cb),
 291                          self);
 292
 293         /* emit NewChannel on the ChannelManager iface */
 294         tp_channel_manager_emit_new_channel(self,
 295                                             TP_EXPORTABLE_CHANNEL(channel),
 296                                             NULL);
 297
 298 }
 299
 300 /*
 301  * TLS Channel class - instance methods
 302  */
 303 enum {
 304         CHANNEL_PROP_SERVER_CERTIFICATE = 1,
 305         CHANNEL_PROP_HOSTNAME,
 306         CHANNEL_PROP_REFERENCE_IDENTITIES,
 307         CHANNEL_LAST_PROP
 308 };
 309
 310 static void channel_get_property(GObject *object,
 311                                  guint property_id,
 312                                  GValue *value,
 313                                  GParamSpec *pspec)
 314 {
 315         SipeTLSChannel *self = SIPE_TLS_CHANNEL(object);
 316
 317         switch (property_id) {
 318         case CHANNEL_PROP_SERVER_CERTIFICATE:
 319                 g_value_set_boxed(value, self->tls_info->cert_path);
 320                 break;
 321         case CHANNEL_PROP_HOSTNAME:
 322                 g_value_set_string(value, self->tls_info->hostname);
 323                 break;
 324         case CHANNEL_PROP_REFERENCE_IDENTITIES:
 325                 g_value_set_boxed(value, self->tls_info->reference_identities);
 326                 break;
 327         default:
 328                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 329                 break;
 330         }
 331 }
 332
 333 static void channel_fill_immutable_properties(TpBaseChannel *channel,
 334                                               GHashTable *properties)
 335 {
 336         TP_BASE_CHANNEL_CLASS(sipe_tls_channel_parent_class)->fill_immutable_properties(channel,
 337                                                                                            properties);
 338         tp_dbus_properties_mixin_fill_properties_hash(G_OBJECT(channel),
 339                                                       properties,
 340                                                       TP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION, "ServerCertificate",
 341                                                       TP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION, "Hostname",
 342                                                       TP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION, "ReferenceIdentities",
 343                                                       NULL);
 344 }
 345
 346 static gchar *channel_get_object_path_suffix(TpBaseChannel *base)
 347 {
 348         return(g_strdup_printf("TLSChannel_%p", base));
 349 }
 350
 351 static void sipe_tls_channel_constructed(GObject *object)
 352 {
 353         SipeTLSChannel *self        = SIPE_TLS_CHANNEL(object);
 354         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_tls_channel_parent_class)->constructed;
 355
 356         if (chain_up)
 357                 chain_up(object);
 358
 359         /* @TODO */
 360         (void)self;
 361 }
 362
 363 static void sipe_tls_channel_finalize(GObject *object)
 364 {
 365         SipeTLSChannel *self = SIPE_TLS_CHANNEL(object);
 366
 367         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSChannel::finalize");
 368
 369         g_simple_async_result_complete(self->result);
 370         g_clear_object(&self->result);
 371
 372         G_OBJECT_CLASS(sipe_tls_channel_parent_class)->finalize(object);
 373 }
 374
 375 /*
 376  * TLS Channel class - type implementation
 377  */
 378 static void sipe_tls_channel_class_init(SipeTLSChannelClass *klass)
 379 {
 380         static TpDBusPropertiesMixinPropImpl props[] = {
 381                 {
 382                         .name        = "ServerCertificate",
 383                         .getter_data = "server-certificate",
 384                         .setter_data = NULL
 385                 },
 386                 {
 387                         .name        = "Hostname",
 388                         .getter_data = "hostname",
 389                         .setter_data = NULL
 390                 },
 391                 {
 392                         .name        = "ReferenceIdentities",
 393                         .getter_data = "reference-identities",
 394                         .setter_data = NULL
 395                 },
 396                 {
 397                         .name        = NULL
 398                 }
 399         };
 400         GObjectClass *object_class     = G_OBJECT_CLASS(klass);
 401         TpBaseChannelClass *base_class = TP_BASE_CHANNEL_CLASS(klass);
 402         GParamSpec *ps;
 403
 404         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSChannel::class_init");
 405
 406         object_class->constructed      = sipe_tls_channel_constructed;
 407         object_class->finalize         = sipe_tls_channel_finalize;
 408         object_class->get_property     = channel_get_property;
 409
 410         base_class->channel_type       = TP_IFACE_CHANNEL_TYPE_SERVER_TLS_CONNECTION;
 411         base_class->target_handle_type = TP_HANDLE_TYPE_NONE;
 412         base_class->fill_immutable_properties = channel_fill_immutable_properties;
 413         base_class->get_object_path_suffix    = channel_get_object_path_suffix;
 414         base_class->interfaces         = NULL;
 415         base_class->close              = tp_base_channel_destroyed;
 416
 417         ps = g_param_spec_boxed("server-certificate",
 418                                 "Server certificate path",
 419                                 "The object path of the server certificate.",
 420                                 DBUS_TYPE_G_OBJECT_PATH,
 421                                 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 422         g_object_class_install_property(object_class,
 423                                         CHANNEL_PROP_SERVER_CERTIFICATE,
 424                                         ps);
 425
 426         ps = g_param_spec_string("hostname",
 427                                  "The hostname to be verified",
 428                                  "The hostname which should be certified by the server certificate.",
 429                                  NULL,
 430                                  G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 431         g_object_class_install_property(object_class,
 432                                         CHANNEL_PROP_HOSTNAME,
 433                                         ps);
 434
 435         ps = g_param_spec_boxed("reference-identities",
 436                                 "The various identities to check the certificate against",
 437                                 "The server certificate identity should match one of these identities.",
 438                                 G_TYPE_STRV,
 439                                 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 440         g_object_class_install_property(object_class,
 441                                         CHANNEL_PROP_REFERENCE_IDENTITIES,
 442                                         ps);
 443
 444         tp_dbus_properties_mixin_implement_interface(object_class,
 445                                                      TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_TLS_CONNECTION,
 446                                                      tp_dbus_properties_mixin_getter_gobject_properties,
 447                                                      NULL,
 448                                                      props);
 449 }
 450
 451 static void sipe_tls_channel_init(SIPE_UNUSED_PARAMETER SipeTLSChannel *self)
 452 {
 453         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSChannel::init");
 454 }
 455
 456 /*
 457  * TLS Certificate class - instance methods
 458  */
 459 enum {
 460         CERTIFICATE_PROP_OBJECT_PATH = 1,
 461         CERTIFICATE_PROP_STATE,
 462         CERTIFICATE_PROP_TYPE,
 463         CERTIFICATE_PROP_CHAIN_DATA,
 464         CERTIFICATE_LAST_PROP
 465 };
 466
 467 static void certificate_get_property(GObject *object,
 468                                      guint property_id,
 469                                      GValue *value,
 470                                      GParamSpec *pspec)
 471 {
 472         SipeTLSCertificate *self = SIPE_TLS_CERTIFICATE(object);
 473
 474         switch (property_id) {
 475         case CERTIFICATE_PROP_OBJECT_PATH:
 476                 g_value_set_string(value, self->tls_info->cert_path);
 477                 break;
 478         case CERTIFICATE_PROP_STATE:
 479                 g_value_set_uint(value, self->state);
 480                 break;
 481         case CERTIFICATE_PROP_TYPE:
 482                 g_value_set_string(value, "x509");
 483                 break;
 484         case CERTIFICATE_PROP_CHAIN_DATA:
 485                 g_value_set_boxed(value, self->tls_info->cert_data);
 486                 break;
 487         default:
 488                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 489                 break;
 490         }
 491 }
 492
 493 static void sipe_tls_certificate_constructed(GObject *object)
 494 {
 495         SipeTLSCertificate *self    = SIPE_TLS_CERTIFICATE(object);
 496         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_tls_certificate_parent_class)->constructed;
 497
 498         if (chain_up)
 499                 chain_up(object);
 500
 501         self->state = SIPE_TLS_CERTIFICATE_PENDING;
 502 }
 503
 504 static void sipe_tls_certificate_finalize(GObject *object)
 505 {
 506         SipeTLSCertificate *self = SIPE_TLS_CERTIFICATE(object);
 507
 508         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSCertificate::finalize");
 509
 510         /* @TODO */
 511         (void)self;
 512
 513         G_OBJECT_CLASS(sipe_tls_certificate_parent_class)->finalize(object);
 514 }
 515
 516 /*
 517  * TLS Certificate class - type implementation
 518  */
 519 static void sipe_tls_certificate_class_init(SipeTLSCertificateClass *klass)
 520 {
 521         static TpDBusPropertiesMixinPropImpl props[] = {
 522                 {
 523                         .name        = "State",
 524                         .getter_data = "state",
 525                         .setter_data = NULL
 526                 },
 527                 {
 528                         .name        = "CertificateType",
 529                         .getter_data = "certificate-type",
 530                         .setter_data = NULL
 531                 },
 532                 {
 533                         .name        = "CertificateChainData",
 534                         .getter_data = "certificate-chain-data",
 535                         .setter_data = NULL
 536                 },
 537                 {
 538                         .name        = NULL
 539                 }
 540         };
 541         static TpDBusPropertiesMixinIfaceImpl prop_interfaces[] = {
 542                 {
 543                         .name   = TP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
 544                         .getter = tp_dbus_properties_mixin_getter_gobject_properties,
 545                         .setter = NULL,
 546                         .props  = props
 547                 },
 548                 {
 549                         .name   = NULL
 550                 }
 551         };
 552         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 553         GParamSpec *ps;
 554
 555         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSCertificate::class_init");
 556
 557         klass->dbus_props_class.interfaces = prop_interfaces;
 558
 559         object_class->constructed      = sipe_tls_certificate_constructed;
 560         object_class->finalize         = sipe_tls_certificate_finalize;
 561         object_class->get_property     = certificate_get_property;
 562
 563         ps = g_param_spec_string("object-path",
 564                                  "D-Bus object path",
 565                                  "The D-Bus object path used for this object on the bus.",
 566                                  NULL,
 567                                  G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 568         g_object_class_install_property(object_class,
 569                                         CERTIFICATE_PROP_OBJECT_PATH,
 570                                         ps);
 571
 572         ps = g_param_spec_uint("state",
 573                                "State of this certificate",
 574                                "The state of this TLS certificate.",
 575                                SIPE_TLS_CERTIFICATE_PENDING,
 576                                SIPE_TLS_CERTIFICATE_ACCEPTED,
 577                                SIPE_TLS_CERTIFICATE_PENDING,
 578                                G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 579         g_object_class_install_property(object_class,
 580                                         CERTIFICATE_PROP_STATE,
 581                                         ps);
 582
 583         ps = g_param_spec_string("certificate-type",
 584                                  "The certificate type",
 585                                  "The type of this certificate.",
 586                                  NULL,
 587                                  G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 588         g_object_class_install_property(object_class,
 589                                         CERTIFICATE_PROP_TYPE,
 590                                         ps);
 591
 592         ps = g_param_spec_boxed("certificate-chain-data",
 593                                 "The certificate chain data",
 594                                 "The raw PEM-encoded trust chain of this certificate.",
 595                                 TP_ARRAY_TYPE_UCHAR_ARRAY_LIST,
 596                                 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 597         g_object_class_install_property(object_class,
 598                                         CERTIFICATE_PROP_CHAIN_DATA, ps);
 599
 600         tp_dbus_properties_mixin_class_init(object_class,
 601                                             G_STRUCT_OFFSET(SipeTLSCertificateClass, dbus_props_class));
 602 }
 603
 604 static void sipe_tls_certificate_init(SIPE_UNUSED_PARAMETER SipeTLSCertificate *self)
 605 {
 606         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSCertificate::init");
 607 }
 608
 609 /*
 610  * TLS Certificate class - interface implementation
 611  */
 612 static void tls_certificate_accept(TpSvcAuthenticationTLSCertificate *certificate,
 613                                    DBusGMethodInvocation *context)
 614 {
 615         SipeTLSCertificate *self = SIPE_TLS_CERTIFICATE(certificate);
 616
 617         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSCertificate::accept");
 618
 619         if (self->state != SIPE_TLS_CERTIFICATE_PENDING) {
 620                 GError error = {
 621                         TP_ERROR,
 622                         TP_ERROR_INVALID_ARGUMENT,
 623                         "Calling Accept() on a certificate with state != PENDING "
 624                         "doesn't make sense."
 625                         };
 626
 627                 dbus_g_method_return_error(context, &error);
 628                 return;
 629         }
 630
 631         self->state = SIPE_TLS_CERTIFICATE_ACCEPTED;
 632         tp_svc_authentication_tls_certificate_emit_accepted(self);
 633
 634         tp_svc_authentication_tls_certificate_return_from_accept(context);
 635 }
 636
 637 static void tls_certificate_reject(TpSvcAuthenticationTLSCertificate *certificate,
 638                                    const GPtrArray *rejections,
 639                                    DBusGMethodInvocation *context)
 640 {
 641         SipeTLSCertificate *self = SIPE_TLS_CERTIFICATE(certificate);
 642
 643         SIPE_DEBUG_INFO_NOFORMAT("SipeTLSCertificate::reject");
 644
 645         if (self->state != SIPE_TLS_CERTIFICATE_PENDING) {
 646                 GError error = {
 647                         TP_ERROR,
 648                         TP_ERROR_INVALID_ARGUMENT,
 649                         "Calling Reject() on a certificate with state != PENDING "
 650                         "doesn't make sense."
 651                 };
 652
 653                 dbus_g_method_return_error(context, &error);
 654                 return;
 655         }
 656
 657         self->state = SIPE_TLS_CERTIFICATE_REJECTED;
 658
 659         tp_svc_authentication_tls_certificate_emit_rejected(self, rejections);
 660
 661         tp_svc_authentication_tls_certificate_return_from_reject(context);
 662 }
 663
 664 static void tls_certificate_iface_init(gpointer g_iface,
 665                                        SIPE_UNUSED_PARAMETER gpointer iface_data)
 666 {
 667         TpSvcAuthenticationTLSCertificateClass *klass = g_iface;
 668
 669 #define IMPLEMENT(x) \
 670         tp_svc_authentication_tls_certificate_implement_##x(    \
 671                 klass, tls_certificate_##x)
 672         IMPLEMENT(accept);
 673         IMPLEMENT(reject);
 674 #undef IMPLEMENT
 675 }
 676
 677 struct sipe_tls_info *sipe_telepathy_tls_info_new(const gchar *hostname,
 678                                                   GTlsCertificate *certificate)
 679 {
 680         struct sipe_tls_info *tls_info = NULL;
 681         gchar *pem;
 682
 683         g_object_get(certificate, "certificate-pem", &pem, NULL);
 684         if (pem) {
 685                 guint length = strlen(pem);
 686                 GArray *array = g_array_sized_new(TRUE,
 687                                                   FALSE,
 688                                                   sizeof(guchar),
 689                                                   length);
 690
 691                 SIPE_DEBUG_INFO("sipe_telepathy_tls_info_new: '%s' (%d)", pem, length);
 692
 693                 tls_info = g_new0(struct sipe_tls_info, 1);
 694                 tls_info->hostname             = g_strdup(hostname);
 695                 tls_info->reference_identities = g_strsplit("", "", 0);
 696
 697                 array = g_array_append_vals(array, pem, length);
 698                 g_free(pem);
 699
 700                 tls_info->cert_data = g_ptr_array_new_full(1, (GDestroyNotify) g_array_unref);
 701                 g_ptr_array_add(tls_info->cert_data, array);
 702         }
 703
 704         return(tls_info);
 705 }
 706
 707 void sipe_telepathy_tls_info_free(struct sipe_tls_info *tls_info)
 708 {
 709         g_object_unref(tls_info->certificate);
 710         g_free(tls_info->hostname);
 711         g_free(tls_info->cert_path);
 712         g_ptr_array_unref(tls_info->cert_data);
 713         g_strfreev(tls_info->reference_identities);
 714         g_free(tls_info);
 715 }
 716
 717 /* create new tls certificate object */
 718 void sipe_telepathy_tls_verify_async(GObject *connection,
 719                                      struct sipe_tls_info *tls_info,
 720                                      GAsyncReadyCallback callback,
 721                                      gpointer user_data)
 722 {
 723         struct sipe_backend_private *telepathy_private = sipe_telepathy_connection_private(connection);
 724         /* property "connection" required by TpBaseChannel */
 725         SipeTLSChannel *channel = g_object_new(SIPE_TYPE_TLS_CHANNEL,
 726                                                "connection", connection,
 727                                                NULL);
 728         TpBaseChannel *base = TP_BASE_CHANNEL(channel);
 729         SipeTLSCertificate *certificate = g_object_new(SIPE_TYPE_TLS_CERTIFICATE,
 730                                                        NULL);
 731         TpDBusDaemon *daemon = tp_dbus_daemon_dup(NULL);
 732
 733         tls_info->certificate = certificate;
 734         channel->tls_info     = tls_info;
 735         certificate->tls_info = tls_info;
 736
 737         tp_base_channel_register(base);
 738         tls_info->cert_path = g_strdup_printf("%s/TLSCertificateObject",
 739                                               tp_base_channel_get_object_path(base));
 740
 741         /* register the certificate on the bus */
 742         tp_dbus_daemon_register_object(daemon,
 743                                        tls_info->cert_path,
 744                                        certificate);
 745         g_object_unref(daemon);
 746
 747         channel->result = g_simple_async_result_new(G_OBJECT(channel),
 748                                                     callback,
 749                                                     user_data,
 750                                                     sipe_telepathy_tls_verify_async);
 751
 752         manager_new_channel(telepathy_private->tls_manager, channel);
 753 }
 754
 755 /*
 756   Local Variables:
 757   mode: c
 758   c-file-style: "bsd"
 759   indent-tabs-mode: t
 760   tab-width: 8
 761   End:
 762 */