src/telepathy/telepathy-connection.c

   1 /**
   2  * @file telepathy-connection.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2012-2016 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
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <string.h>
  28 #include <sys/stat.h>
  29
  30 #include <glib-object.h>
  31 #include <glib/gstdio.h>
  32 #include <telepathy-glib/base-connection.h>
  33 #include <telepathy-glib/base-protocol.h>
  34 #include <telepathy-glib/contacts-mixin.h>
  35 #include <telepathy-glib/handle-repo-dynamic.h>
  36 #include <telepathy-glib/presence-mixin.h>
  37 #include <telepathy-glib/simple-password-manager.h>
  38 #include <telepathy-glib/telepathy-glib.h>
  39
  40 #include "sipe-backend.h"
  41 #include "sipe-common.h"
  42 #include "sipe-core.h"
  43
  44 #include "telepathy-private.h"
  45
  46 G_BEGIN_DECLS
  47 /*
  48  * Connection class - data structures
  49  */
  50 typedef struct _SipeConnectionClass {
  51         TpBaseConnectionClass parent_class;
  52         TpDBusPropertiesMixinClass properties_mixin;
  53         TpContactsMixinClass contacts_mixin;
  54         TpPresenceMixinClass presence_mixin;
  55 } SipeConnectionClass;
  56
  57 typedef struct _SipeConnection {
  58         TpBaseConnection parent;
  59         TpContactsMixinClass contacts_mixin;
  60         TpPresenceMixin presence_mixin;
  61
  62         /* channel managers */
  63         TpSimplePasswordManager *password_manager;
  64         struct _SipeContactList *contact_list;
  65         struct _SipeTLSManager  *tls_manager;
  66
  67         struct sipe_backend_private private;
  68         gchar *account;
  69         gchar *login;
  70         gchar *password;
  71         gchar *server;
  72         gchar *port;
  73         guint  transport;
  74         guint  authentication_type;
  75         gchar *user_agent;
  76         gchar *authentication;
  77         gboolean sso;
  78         gboolean dont_publish;
  79         gboolean is_disconnecting;
  80
  81         GPtrArray *contact_info_fields;
  82 } SipeConnection;
  83
  84 #define SIPE_PUBLIC_TO_CONNECTION sipe_public->backend_private->connection
  85
  86 /*
  87  * Connection class - type macros
  88  */
  89 static GType sipe_connection_get_type(void) G_GNUC_CONST;
  90 #define SIPE_TYPE_CONNECTION \
  91         (sipe_connection_get_type())
  92 #define SIPE_CONNECTION(obj) \
  93         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_CONNECTION, \
  94                                     SipeConnection))
  95 G_END_DECLS
  96
  97 /*
  98  * Connection class - type definition
  99  */
 100 static void init_aliasing (gpointer, gpointer);
 101 G_DEFINE_TYPE_WITH_CODE(SipeConnection,
 102                         sipe_connection,
 103                         TP_TYPE_BASE_CONNECTION,
 104                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_ALIASING,
 105                                               init_aliasing);
 106                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_AVATARS,
 107                                               sipe_telepathy_avatars_iface_init);
 108                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACTS,
 109                                               tp_contacts_mixin_iface_init);
 110                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACT_GROUPS,
 111                                               tp_base_contact_list_mixin_groups_iface_init);
 112                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACT_INFO,
 113                                               sipe_telepathy_contact_info_iface_init);
 114                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_CONTACT_LIST,
 115                                               tp_base_contact_list_mixin_list_iface_init);
 116                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_PRESENCE,
 117                                               tp_presence_mixin_iface_init);
 118                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_CONNECTION_INTERFACE_SIMPLE_PRESENCE,
 119                                               tp_presence_mixin_simple_presence_iface_init);
 120                         G_IMPLEMENT_INTERFACE(TP_TYPE_SVC_DBUS_PROPERTIES,
 121                                               tp_dbus_properties_mixin_iface_init);
 122 )
 123
 124
 125 /*
 126  * Connection class - instance methods
 127  */
 128 static gchar *normalize_contact(SIPE_UNUSED_PARAMETER TpHandleRepoIface *repo,
 129                                 const gchar *id,
 130                                 SIPE_UNUSED_PARAMETER gpointer context,
 131                                 GError **error)
 132 {
 133         return(sipe_telepathy_protocol_normalize_contact(NULL, id, error));
 134 }
 135
 136 static void create_handle_repos(SIPE_UNUSED_PARAMETER TpBaseConnection *conn,
 137                                 TpHandleRepoIface *repos[NUM_TP_HANDLE_TYPES])
 138 {
 139         repos[TP_HANDLE_TYPE_CONTACT] = tp_dynamic_handle_repo_new(TP_HANDLE_TYPE_CONTACT,
 140                                                                    normalize_contact,
 141                                                                    NULL);
 142 }
 143
 144 static gboolean connect_to_core(SipeConnection *self,
 145                                 GError **error)
 146 {
 147         struct sipe_core_public *sipe_public;
 148         const gchar *errmsg;
 149
 150         sipe_public = sipe_core_allocate(self->account,
 151                                          self->sso,
 152                                          self->login,
 153                                          self->password,
 154                                          NULL, /* @TODO: email     */
 155                                          NULL, /* @TODO: email_url */
 156                                          &errmsg);
 157
 158         SIPE_DEBUG_INFO("connect_to_core: created %p", sipe_public);
 159
 160         if (sipe_public) {
 161                 struct sipe_backend_private *telepathy_private = &self->private;
 162
 163                 /* initialize backend private data */
 164                 sipe_public->backend_private    = telepathy_private;
 165                 telepathy_private->public       = sipe_public;
 166                 telepathy_private->contact_list = self->contact_list;
 167                 telepathy_private->connection   = self;
 168                 telepathy_private->activity     = SIPE_ACTIVITY_UNSET;
 169                 telepathy_private->cache_dir    = g_build_path(G_DIR_SEPARATOR_S,
 170                                                                g_get_user_cache_dir(),
 171                                                                "telepathy",
 172                                                                "sipe",
 173                                                                self->account,
 174                                                                NULL);
 175                 telepathy_private->message      = NULL;
 176                 telepathy_private->tls_manager  = self->tls_manager;
 177                 telepathy_private->transport    = NULL;
 178
 179                 /* make sure cache directory exists */
 180                 if (!g_file_test(telepathy_private->cache_dir,
 181                                  G_FILE_TEST_IS_DIR) &&
 182                     (g_mkdir_with_parents(telepathy_private->cache_dir,
 183                                           S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
 184                      == 0))
 185                         SIPE_DEBUG_INFO("connect_to_core: created cache directory %s",
 186                                         telepathy_private->cache_dir);
 187
 188                 SIPE_CORE_FLAG_UNSET(DONT_PUBLISH);
 189                 if (self->dont_publish)
 190                         SIPE_CORE_FLAG_SET(DONT_PUBLISH);
 191
 192                 sipe_core_transport_sip_connect(sipe_public,
 193                                                 self->transport,
 194                                                 self->authentication_type,
 195                                                 self->server,
 196                                                 self->port);
 197
 198                 return(TRUE);
 199         } else {
 200                 g_set_error_literal(error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
 201                                     errmsg);
 202                 return(FALSE);
 203         }
 204 }
 205
 206 static void password_manager_cb(GObject *source,
 207                                 GAsyncResult *result,
 208                                 gpointer data)
 209 {
 210         SipeConnection   *self  = data;
 211         TpBaseConnection *base  = TP_BASE_CONNECTION(self);
 212         GError *error           = NULL;
 213         const GString *password = tp_simple_password_manager_prompt_finish(
 214                 TP_SIMPLE_PASSWORD_MANAGER(source),
 215                 result,
 216                 &error);
 217
 218         if (password == NULL) {
 219                 SIPE_DEBUG_ERROR("password_manager_cb: failed: %s",
 220                                  error ? error->message : "UNKNOWN");
 221
 222                 if (base->status != TP_CONNECTION_STATUS_DISCONNECTED) {
 223                         tp_base_connection_disconnect_with_dbus_error(base,
 224                                                                       error ? tp_error_get_dbus_name(error->code) : "",
 225                                                                       NULL,
 226                                                                       TP_CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED);
 227                 }
 228                 g_error_free(error);
 229         } else {
 230
 231                 g_free(self->password);
 232                 self->password = g_strdup(password->str);
 233
 234                 if (!connect_to_core(self, &error)) {
 235                         if (base->status != TP_CONNECTION_STATUS_DISCONNECTED) {
 236                                 tp_base_connection_disconnect_with_dbus_error(base,
 237                                                                               tp_error_get_dbus_name(error->code),
 238                                                                               NULL,
 239                                                                               TP_CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED);
 240                         }
 241                         g_error_free(error);
 242                 }
 243         }
 244 }
 245
 246 static gboolean start_connecting(TpBaseConnection *base,
 247                                  GError **error)
 248 {
 249         SipeConnection *self = SIPE_CONNECTION(base);
 250         gboolean        rc   = TRUE;
 251         gchar          *uri  = sipe_telepathy_protocol_normalize_contact(NULL,
 252                                                                          self->account,
 253                                                                          error);
 254
 255         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::start_connecting");
 256
 257         /* set up mandatory self-handle */
 258         if (uri) {
 259                 base->self_handle = tp_handle_ensure(tp_base_connection_get_handles(base,
 260                                                                                     TP_HANDLE_TYPE_CONTACT),
 261                                                      uri,
 262                                                      NULL,
 263                                                      error);
 264                 g_free(uri);
 265                 if (!base->self_handle) {
 266                         SIPE_DEBUG_ERROR("SipeConnection::start_connecting: self handle creation failed: %s",
 267                                          (*error)->message);
 268                         return(FALSE);
 269                 }
 270         } else {
 271                 SIPE_DEBUG_ERROR("SipeConnection::start_connecting: %s",
 272                                  (*error)->message);
 273                 return(FALSE);
 274         }
 275
 276         tp_base_connection_change_status(base, TP_CONNECTION_STATUS_CONNECTING,
 277                                          TP_CONNECTION_STATUS_REASON_REQUESTED);
 278
 279         /* map option list to flags - default is automatic */
 280         self->authentication_type = SIPE_AUTHENTICATION_TYPE_AUTOMATIC;
 281         if (sipe_strequal(self->authentication, "ntlm")) {
 282                 SIPE_DEBUG_INFO_NOFORMAT("start_connecting: NTLM selected");
 283                 self->authentication_type = SIPE_AUTHENTICATION_TYPE_NTLM;
 284         } else
 285 #ifdef HAVE_GSSAPI_GSSAPI_H
 286         if (sipe_strequal(self->authentication, "krb5")) {
 287                 SIPE_DEBUG_INFO_NOFORMAT("start_connecting: KRB5 selected");
 288                 self->authentication_type = SIPE_AUTHENTICATION_TYPE_KERBEROS;
 289         } else
 290 #endif
 291         if (sipe_strequal(self->authentication, "tls-dsk")) {
 292                 SIPE_DEBUG_INFO_NOFORMAT("start_connecting: TLS-DSK selected");
 293                 self->authentication_type = SIPE_AUTHENTICATION_TYPE_TLS_DSK;
 294         }
 295
 296         /* Only ask for a password when required */
 297         if (!sipe_core_transport_sip_requires_password(self->authentication_type,
 298                                                        self->sso) ||
 299             (self->password && strlen(self->password)))
 300                 rc = connect_to_core(self, error);
 301         else {
 302                 SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::start_connecting: requesting password from user");
 303                 tp_simple_password_manager_prompt_async(self->password_manager,
 304                                                         password_manager_cb,
 305                                                         self);
 306         }
 307
 308         return(rc);
 309 }
 310
 311 static gboolean disconnect_from_core(gpointer data)
 312 {
 313         TpBaseConnection *base                         = data;
 314         SipeConnection *self                           = SIPE_CONNECTION(base);
 315         struct sipe_backend_private *telepathy_private = &self->private;
 316         struct sipe_core_public *sipe_public           = telepathy_private->public;
 317
 318         SIPE_DEBUG_INFO("disconnect_from_core: %p", sipe_public);
 319
 320         if (sipe_public)
 321                 sipe_core_deallocate(sipe_public);
 322         telepathy_private->public    = NULL;
 323         telepathy_private->transport = NULL;
 324
 325         g_free(telepathy_private->message);
 326         telepathy_private->message   = NULL;
 327
 328         g_free(telepathy_private->cache_dir);
 329         telepathy_private->cache_dir = NULL;
 330
 331         SIPE_DEBUG_INFO_NOFORMAT("disconnect_from_core: core deallocated");
 332
 333         /* now it is OK to destroy the connection object */
 334         tp_base_connection_finish_shutdown(base);
 335
 336         return(FALSE);
 337 }
 338
 339 static void shut_down(TpBaseConnection *base)
 340 {
 341         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::shut_down");
 342
 343         /* this can be called synchronously, defer destruction */
 344         g_idle_add(disconnect_from_core, base);
 345 }
 346
 347 static GPtrArray *create_channel_managers(TpBaseConnection *base)
 348 {
 349         SipeConnection *self = SIPE_CONNECTION(base);
 350         GPtrArray *channel_managers = g_ptr_array_new();
 351
 352         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::create_channel_managers");
 353
 354         self->contact_list = sipe_telepathy_contact_list_new(base);
 355         g_ptr_array_add(channel_managers, self->contact_list);
 356
 357         self->password_manager = tp_simple_password_manager_new(base);
 358         g_ptr_array_add(channel_managers, self->password_manager);
 359
 360         g_ptr_array_add(channel_managers, sipe_telepathy_search_new(base));
 361
 362         self->tls_manager = sipe_telepathy_tls_new(base);
 363         g_ptr_array_add(channel_managers, self->tls_manager);
 364
 365         return(channel_managers);
 366 }
 367
 368 static void aliasing_fill_contact_attributes(GObject *object,
 369                                              const GArray *contacts,
 370                                              GHashTable *attributes)
 371 {
 372         SipeConnection *self = SIPE_CONNECTION(object);
 373         guint i;
 374
 375         for (i = 0; i < contacts->len; i++) {
 376                 TpHandle contact = g_array_index(contacts, guint, i);
 377
 378                 tp_contacts_mixin_set_contact_attribute(attributes,
 379                                                         contact,
 380                                                         TP_TOKEN_CONNECTION_INTERFACE_ALIASING_ALIAS,
 381                                                         tp_g_value_slice_new_string(
 382                                                                 sipe_telepathy_buddy_get_alias(self->contact_list,
 383                                                                                                contact)));
 384         }
 385 }
 386
 387 static void avatars_fill_contact_attributes(GObject *object,
 388                                             const GArray *contacts,
 389                                             GHashTable *attributes)
 390 {
 391         SipeConnection *self = SIPE_CONNECTION(object);
 392         guint i;
 393
 394         for (i = 0; i < contacts->len; i++) {
 395                 TpHandle contact = g_array_index(contacts, guint, i);
 396                 const gchar *hash = sipe_telepathy_buddy_get_hash(self->contact_list,
 397                                                                   contact);
 398
 399                 if (!hash) hash = "";
 400                 tp_contacts_mixin_set_contact_attribute(attributes,
 401                                                         contact,
 402                                                         TP_IFACE_CONNECTION_INTERFACE_AVATARS"/token",
 403                                                         tp_g_value_slice_new_string(hash));
 404         }
 405 }
 406
 407 static void contact_info_properties_getter(GObject *object,
 408                                            SIPE_UNUSED_PARAMETER GQuark interface,
 409                                            GQuark name,
 410                                            GValue *value,
 411                                            gpointer getter_data)
 412 {
 413         GQuark fields = g_quark_from_static_string("SupportedFields");
 414
 415         if (name == fields)
 416                 g_value_set_boxed(value,
 417                                   SIPE_CONNECTION(object)->contact_info_fields);
 418         else
 419                 g_value_set_uint(value,
 420                                  GPOINTER_TO_UINT(getter_data));
 421 }
 422
 423 static void sipe_connection_constructed(GObject *object)
 424 {
 425         SipeConnection *self   = SIPE_CONNECTION(object);
 426         TpBaseConnection *base = TP_BASE_CONNECTION(object);
 427         void (*chain_up)(GObject *) = G_OBJECT_CLASS(sipe_connection_parent_class)->constructed;
 428
 429         if (chain_up)
 430                 chain_up(object);
 431
 432         tp_contacts_mixin_init(object,
 433                                G_STRUCT_OFFSET(SipeConnection, contacts_mixin));
 434         tp_base_connection_register_with_contacts_mixin(base);
 435
 436         tp_base_contact_list_mixin_register_with_contacts_mixin(base);
 437
 438         tp_contacts_mixin_add_contact_attributes_iface(object,
 439                                                        TP_IFACE_CONNECTION_INTERFACE_ALIASING,
 440                                                        aliasing_fill_contact_attributes);
 441         tp_contacts_mixin_add_contact_attributes_iface(object,
 442                                                        TP_IFACE_CONNECTION_INTERFACE_AVATARS,
 443                                                        avatars_fill_contact_attributes);
 444
 445         tp_presence_mixin_init(object,
 446                                G_STRUCT_OFFSET(SipeConnection,
 447                                                presence_mixin));
 448         tp_presence_mixin_simple_presence_register_with_contacts_mixin(object);
 449
 450         self->contact_info_fields = sipe_telepathy_contact_info_fields();
 451 }
 452
 453 static void sipe_connection_finalize(GObject *object)
 454 {
 455         SipeConnection *self = SIPE_CONNECTION(object);
 456
 457         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::finalize");
 458
 459         tp_contacts_mixin_finalize(object);
 460         tp_presence_mixin_finalize(object);
 461         g_boxed_free(TP_ARRAY_TYPE_FIELD_SPECS, self->contact_info_fields);
 462
 463         g_free(self->authentication);
 464         g_free(self->user_agent);
 465         g_free(self->port);
 466         g_free(self->server);
 467         g_free(self->password);
 468         g_free(self->login);
 469         g_free(self->account);
 470
 471         G_OBJECT_CLASS(sipe_connection_parent_class)->finalize(object);
 472 }
 473
 474 /*
 475  * Connection class - type implementation
 476  */
 477 static const gchar *interfaces_always_present[] = {
 478         /* @TODO */
 479         TP_IFACE_CONNECTION_INTERFACE_ALIASING,
 480         TP_IFACE_CONNECTION_INTERFACE_AVATARS,
 481         TP_IFACE_CONNECTION_INTERFACE_CONTACT_GROUPS,
 482         TP_IFACE_CONNECTION_INTERFACE_CONTACT_INFO,
 483         TP_IFACE_CONNECTION_INTERFACE_CONTACT_LIST,
 484         TP_IFACE_CONNECTION_INTERFACE_CONTACTS,
 485         TP_IFACE_CONNECTION_INTERFACE_PRESENCE,
 486         TP_IFACE_CONNECTION_INTERFACE_REQUESTS,
 487         TP_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE,
 488         NULL
 489 };
 490
 491 static void sipe_connection_class_init(SipeConnectionClass *klass)
 492 {
 493         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 494         TpBaseConnectionClass *base_class = TP_BASE_CONNECTION_CLASS(klass);
 495         static TpDBusPropertiesMixinIfaceImpl prop_interfaces[] = {
 496                 {
 497                         /* 0 */
 498                         .name   = TP_IFACE_CONNECTION_INTERFACE_CONTACT_INFO,
 499                         .getter = contact_info_properties_getter,
 500                         .setter = NULL,
 501                 },
 502                 {
 503                         /* LAST! */
 504                         .name   = NULL,
 505                 }
 506         };
 507
 508         /* initalize non-constant fields */
 509         prop_interfaces[0].props = sipe_telepathy_contact_info_props();
 510
 511         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::class_init");
 512
 513         object_class->constructed = sipe_connection_constructed;
 514         object_class->finalize    = sipe_connection_finalize;
 515
 516         base_class->create_handle_repos     = create_handle_repos;
 517         base_class->start_connecting        = start_connecting;
 518         base_class->shut_down               = shut_down;
 519         base_class->create_channel_managers = create_channel_managers;
 520
 521         base_class->interfaces_always_present = interfaces_always_present;
 522
 523         klass->properties_mixin.interfaces = prop_interfaces;
 524         tp_dbus_properties_mixin_class_init(object_class,
 525                                             G_STRUCT_OFFSET(SipeConnectionClass,
 526                                                             properties_mixin));
 527         tp_contacts_mixin_class_init(object_class,
 528                                      G_STRUCT_OFFSET(SipeConnectionClass,
 529                                                      contacts_mixin));
 530         sipe_telepathy_status_init(object_class,
 531                                    G_STRUCT_OFFSET(SipeConnectionClass,
 532                                                    presence_mixin));
 533         tp_presence_mixin_simple_presence_init_dbus_properties(object_class);
 534         tp_base_contact_list_mixin_class_init(base_class);
 535 }
 536
 537 static void sipe_connection_init(SIPE_UNUSED_PARAMETER SipeConnection *self)
 538 {
 539         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::init");
 540 }
 541
 542 /*
 543  * Connection class - interface implementation
 544  *
 545  * Contact aliases
 546  */
 547 static void get_alias_flags(TpSvcConnectionInterfaceAliasing *aliasing,
 548                             DBusGMethodInvocation *context)
 549 {
 550         TpBaseConnection *base = TP_BASE_CONNECTION(aliasing);
 551
 552         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(base, context);
 553         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::get_alias_flags called");
 554
 555         tp_svc_connection_interface_aliasing_return_from_get_alias_flags(context,
 556                                                                          TP_CONNECTION_ALIAS_FLAG_USER_SET);
 557 }
 558
 559 static void get_aliases(TpSvcConnectionInterfaceAliasing *aliasing,
 560                         const GArray *contacts,
 561                         DBusGMethodInvocation *context)
 562 {
 563         SipeConnection *self            = SIPE_CONNECTION(aliasing);
 564         TpBaseConnection *base          = TP_BASE_CONNECTION(aliasing);
 565         TpHandleRepoIface *contact_repo = tp_base_connection_get_handles(base,
 566                                                                          TP_HANDLE_TYPE_CONTACT);
 567         GError *error                   = NULL;
 568         GHashTable *result;
 569         guint i;
 570
 571         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(base, context);
 572         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::get_aliases called");
 573
 574         if (!tp_handles_are_valid(contact_repo, contacts, FALSE, &error)) {
 575                 dbus_g_method_return_error(context, error);
 576                 g_error_free(error);
 577                 return;
 578         }
 579
 580         result = g_hash_table_new(g_direct_hash, g_direct_equal);
 581
 582         for (i = 0; i < contacts->len; i++) {
 583                 TpHandle contact   = g_array_index(contacts, TpHandle, i);
 584                 const gchar *alias = sipe_telepathy_buddy_get_alias(self->contact_list,
 585                                                                     contact);
 586                 g_hash_table_insert(result,
 587                                     GUINT_TO_POINTER(contact),
 588                                     (gchar *) alias);
 589         }
 590
 591         tp_svc_connection_interface_aliasing_return_from_get_aliases(context,
 592                                                                      result);
 593         g_hash_table_unref(result);
 594 }
 595
 596 static void request_aliases(TpSvcConnectionInterfaceAliasing *aliasing,
 597                             const GArray *contacts,
 598                             DBusGMethodInvocation *context)
 599 {
 600         SipeConnection *self            = SIPE_CONNECTION(aliasing);
 601         TpBaseConnection *base          = TP_BASE_CONNECTION(aliasing);
 602         TpHandleRepoIface *contact_repo = tp_base_connection_get_handles(base,
 603                                                                          TP_HANDLE_TYPE_CONTACT);
 604         GError *error                   = NULL;
 605         GPtrArray *result;
 606         gchar **strings;
 607         guint i;
 608
 609         TP_BASE_CONNECTION_ERROR_IF_NOT_CONNECTED(base, context);
 610         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::request_aliases called");
 611
 612         if (!tp_handles_are_valid(contact_repo, contacts, FALSE, &error)) {
 613                 dbus_g_method_return_error(context, error);
 614                 g_error_free(error);
 615                 return;
 616         }
 617
 618         result = g_ptr_array_sized_new(contacts->len + 1);
 619
 620         for (i = 0; i < contacts->len; i++) {
 621                 TpHandle contact   = g_array_index(contacts, TpHandle, i);
 622                 const gchar *alias = sipe_telepathy_buddy_get_alias(self->contact_list,
 623                                                                     contact);
 624                 g_ptr_array_add(result, (gchar *) alias);
 625         }
 626
 627         g_ptr_array_add(result, NULL);
 628         strings = (gchar **) g_ptr_array_free(result, FALSE);
 629
 630         tp_svc_connection_interface_aliasing_return_from_request_aliases(context,
 631                                                                          (const gchar **) strings);
 632         g_free(strings);
 633 }
 634
 635 static void set_aliases(TpSvcConnectionInterfaceAliasing *aliasing,
 636                         GHashTable *aliases,
 637                         DBusGMethodInvocation *context)
 638 {
 639         SipeConnection *self            = SIPE_CONNECTION(aliasing);
 640         TpBaseConnection *base          = TP_BASE_CONNECTION(aliasing);
 641         TpHandleRepoIface *contact_repo = tp_base_connection_get_handles(base,
 642                                                                          TP_HANDLE_TYPE_CONTACT);
 643         GHashTableIter iter;
 644         gpointer key, value;
 645
 646         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::set_aliases called");
 647
 648         g_hash_table_iter_init(&iter, aliases);
 649
 650         while (g_hash_table_iter_next(&iter, &key, NULL)) {
 651                 GError *error = NULL;
 652
 653                 if (!tp_handle_is_valid(contact_repo,
 654                                         GPOINTER_TO_UINT(key),
 655                                         &error)) {
 656                         dbus_g_method_return_error(context, error);
 657                         g_error_free(error);
 658                         return;
 659                 }
 660         }
 661
 662         g_hash_table_iter_init(&iter, aliases);
 663
 664         while (g_hash_table_iter_next(&iter, &key, &value)) {
 665                 sipe_telepathy_buddy_set_alias(self->contact_list,
 666                                                GPOINTER_TO_UINT(key),
 667                                                value);
 668         }
 669
 670         tp_svc_connection_interface_aliasing_return_from_set_aliases(context);
 671 }
 672
 673 static void init_aliasing(gpointer iface,
 674                           SIPE_UNUSED_PARAMETER gpointer iface_data)
 675 {
 676         TpSvcConnectionInterfaceAliasingClass *klass = iface;
 677
 678         SIPE_DEBUG_INFO_NOFORMAT("SipeConnection::init_aliasing called");
 679
 680         tp_svc_connection_interface_aliasing_implement_get_alias_flags(klass, get_alias_flags);
 681         tp_svc_connection_interface_aliasing_implement_request_aliases(klass, request_aliases);
 682         tp_svc_connection_interface_aliasing_implement_get_aliases(klass, get_aliases);
 683         tp_svc_connection_interface_aliasing_implement_set_aliases(klass, set_aliases);
 684 }
 685
 686 /* create new connection object */
 687 TpBaseConnection *sipe_telepathy_connection_new(TpBaseProtocol *protocol,
 688                                                 GHashTable *params,
 689                                                 SIPE_UNUSED_PARAMETER GError **error)
 690 {
 691         SipeConnection *conn = g_object_new(SIPE_TYPE_CONNECTION,
 692                                             "protocol", tp_base_protocol_get_name(protocol),
 693                                             NULL);
 694         const gchar *value;
 695         guint port;
 696         gboolean boolean_value;
 697         gboolean valid;
 698
 699         SIPE_DEBUG_INFO_NOFORMAT("sipe_telepathy_connection_new");
 700
 701         /* initialize private fields */
 702         conn->is_disconnecting = FALSE;
 703
 704         /* account is required field */
 705         conn->account = g_strdup(tp_asv_get_string(params, "account"));
 706
 707         /* if login is not specified, account value will be used in connect_to_core */
 708         value = tp_asv_get_string(params, "login");
 709         if (value && strlen(value))
 710                 conn->login = g_strdup(value);
 711         else
 712                 conn->login = NULL;
 713
 714         /* password */
 715         value = tp_asv_get_string(params, "password");
 716         if (value && strlen(value))
 717                 conn->password = g_strdup(value);
 718         else
 719                 conn->password = NULL;
 720
 721         /* server name */
 722         value = tp_asv_get_string(params, "server");
 723         if (value && strlen(value))
 724                 conn->server = g_strdup(value);
 725         else
 726                 conn->server = NULL;
 727
 728         /* server port: core expects a string */
 729         port = tp_asv_get_uint32(params, "port", &valid);
 730         if (valid)
 731                 conn->port = g_strdup_printf("%d", port);
 732         else
 733                 conn->port = NULL;
 734
 735         /* transport type */
 736         value = tp_asv_get_string(params, "transport");
 737         if (sipe_strequal(value, "auto")) {
 738                 conn->transport = conn->server ?
 739                         SIPE_TRANSPORT_TLS : SIPE_TRANSPORT_AUTO;
 740         } else if (sipe_strequal(value, "tls")) {
 741                 conn->transport = SIPE_TRANSPORT_TLS;
 742         } else {
 743                 conn->transport = SIPE_TRANSPORT_TCP;
 744         }
 745
 746         /* User-Agent: override */
 747         value = tp_asv_get_string(params, "useragent");
 748         if (value && strlen(value))
 749                 conn->user_agent = g_strdup(value);
 750         else
 751                 conn->user_agent = NULL;
 752
 753         /* authentication type */
 754         value = tp_asv_get_string(params, "authentication");
 755         if (value && strlen(value) && strcmp(value, "ntlm"))
 756                 conn->authentication = g_strdup(value);
 757         else
 758                 conn->authentication = NULL; /* NTLM is default */
 759
 760         /* Single Sign-On */
 761         boolean_value = tp_asv_get_boolean(params, "single-sign-on", &valid);
 762         if (valid)
 763                 conn->sso = boolean_value;
 764         else
 765                 conn->sso = FALSE;
 766
 767         /* Don't publish my calendar information */
 768         boolean_value = tp_asv_get_boolean(params, "don't-publish-calendar", &valid);
 769         if (valid)
 770                 conn->dont_publish = boolean_value;
 771         else
 772                 conn->dont_publish = FALSE;
 773
 774         return(TP_BASE_CONNECTION(conn));
 775 }
 776
 777 void sipe_telepathy_connection_alias_updated(TpBaseConnection *connection,
 778                                              guint contact,
 779                                              const gchar *alias)
 780 {
 781         GPtrArray *aliases = g_ptr_array_sized_new(1);
 782         GValueArray *pair  = g_value_array_new(2);
 783
 784         g_value_array_append(pair, NULL);
 785         g_value_array_append(pair, NULL);
 786         g_value_init(pair->values + 0, G_TYPE_UINT);
 787         g_value_init(pair->values + 1, G_TYPE_STRING);
 788         g_value_set_uint(pair->values + 0, contact);
 789         g_value_set_string(pair->values + 1, alias);
 790         g_ptr_array_add(aliases, pair);
 791
 792         tp_svc_connection_interface_aliasing_emit_aliases_changed(SIPE_CONNECTION(connection),
 793                                                                   aliases);
 794
 795         g_ptr_array_unref(aliases);
 796         g_value_array_free(pair);
 797 }
 798
 799 struct sipe_backend_private *sipe_telepathy_connection_private(GObject *object)
 800 {
 801         SipeConnection *self = SIPE_CONNECTION(object);
 802         /* connected to core already? */
 803         if (self->private.public)
 804                 return(&self->private);
 805         else
 806                 return(NULL);
 807 }
 808
 809 /*
 810  * Backend adaptor functions
 811  */
 812 void sipe_backend_connection_completed(struct sipe_core_public *sipe_public)
 813 {
 814         SipeConnection *self   = SIPE_PUBLIC_TO_CONNECTION;
 815         TpBaseConnection *base = TP_BASE_CONNECTION(self);
 816
 817         /* we are only allowed to do this once */
 818         if (base->status != TP_CONNECTION_STATUS_CONNECTED)
 819                 tp_base_connection_change_status(base,
 820                                                  TP_CONNECTION_STATUS_CONNECTED,
 821                                                  TP_CONNECTION_STATUS_REASON_REQUESTED);
 822 }
 823
 824 void sipe_backend_connection_error(struct sipe_core_public *sipe_public,
 825                                    sipe_connection_error error,
 826                                    const gchar *msg)
 827 {
 828         SipeConnection *self   = SIPE_PUBLIC_TO_CONNECTION;
 829         TpBaseConnection *base = TP_BASE_CONNECTION(self);
 830         GHashTable *details    = tp_asv_new("server-message", G_TYPE_STRING, msg,
 831                                             NULL);
 832         TpConnectionStatusReason reason;
 833         const gchar *name;
 834
 835         self->is_disconnecting = TRUE;
 836
 837         switch (error) {
 838         case SIPE_CONNECTION_ERROR_NETWORK:
 839                 reason = TP_CONNECTION_STATUS_REASON_NETWORK_ERROR;
 840                 if (base->status == TP_CONNECTION_STATUS_CONNECTING)
 841                         name = TP_ERROR_STR_CONNECTION_FAILED;
 842                 else
 843                         name = TP_ERROR_STR_CONNECTION_LOST;
 844                 break;
 845
 846         case SIPE_CONNECTION_ERROR_INVALID_USERNAME:
 847         case SIPE_CONNECTION_ERROR_INVALID_SETTINGS:
 848         case SIPE_CONNECTION_ERROR_AUTHENTICATION_FAILED:
 849         case SIPE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE:
 850                 /* copied from haze code. I agree there should be better ones */
 851                 reason = TP_CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED;
 852                 name   = TP_ERROR_STR_AUTHENTICATION_FAILED;
 853                 break;
 854
 855         default:
 856                 reason = TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED;
 857                 name   = TP_ERROR_STR_DISCONNECTED;
 858                 break;
 859         }
 860
 861         SIPE_DEBUG_ERROR("sipe_backend_connection_error: %s (%s)", name, msg);
 862         tp_base_connection_disconnect_with_dbus_error(base,
 863                                                       name,
 864                                                       details,
 865                                                       reason);
 866         g_hash_table_unref(details);
 867 }
 868
 869 gboolean sipe_backend_connection_is_disconnecting(struct sipe_core_public *sipe_public)
 870 {
 871         SipeConnection *self = SIPE_PUBLIC_TO_CONNECTION;
 872
 873         /* disconnect was requested or transport was already disconnected */
 874         return(self->is_disconnecting ||
 875                self->private.transport == NULL);
 876 }
 877
 878 gboolean sipe_backend_connection_is_valid(struct sipe_core_public *sipe_public)
 879 {
 880         return(!sipe_backend_connection_is_disconnecting(sipe_public));
 881 }
 882
 883 const gchar *sipe_backend_setting(struct sipe_core_public *sipe_public,
 884                                   sipe_setting type)
 885 {
 886         SipeConnection *self = SIPE_PUBLIC_TO_CONNECTION;
 887         const gchar *value;
 888
 889         switch (type) {
 890         case SIPE_SETTING_USER_AGENT:
 891                 value = self->user_agent;
 892                 break;
 893         default:
 894                 /* @TODO: update when settings are implemented */
 895                 value = NULL;
 896                 break;
 897         }
 898
 899         return(value);
 900 }
 901
 902
 903 /*
 904   Local Variables:
 905   mode: c
 906   c-file-style: "bsd"
 907   indent-tabs-mode: t
 908   tab-width: 8
 909   End:
 910 */