src/telepathy/telepathy-connection.c

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