src/purple/purple-plugin.c

   1 /**
   2  * @file purple-plugin.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-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 <time.h>
  29
  30 #include <glib.h>
  31
  32 #include "sipe-common.h"
  33
  34 /* Flag needed for correct version of PURPLE_INIT_PLUGIN() */
  35 #ifndef PURPLE_PLUGINS
  36 #define PURPLE_PLUGINS
  37 #endif
  38
  39 /* for LOCALEDIR
  40  * as it's determined on runtime, as Pidgin installation can be anywhere.
  41  */
  42 #ifdef _WIN32
  43 #include "win32/win32dep.h"
  44 #endif
  45
  46 #include "accountopt.h"
  47 #include "blist.h"
  48 #include "connection.h"
  49 #include "core.h"
  50 #include "dnssrv.h"
  51 #ifdef HAVE_VV
  52 #include "media.h"
  53 #endif
  54 #include "prpl.h"
  55 #include "plugin.h"
  56 #include "request.h"
  57 #include "status.h"
  58 /*
  59  * NOTE: Currently PURPLE_VERSION_CHECK(2,y,z) returns FALSE for libpurple >= 3.0.0.
  60  *       See also <http://developer.pidgin.im/ticket/14551>
  61  *
  62  * As a workaround an additional PURPLE_VERSION_CHECK(3,0,0) needs to be added.
  63  */
  64 #include "version.h"
  65
  66 #include "sipe-backend.h"
  67 #include "sipe-core.h"
  68 #include "sipe-nls.h"
  69
  70 #define _PurpleMessageFlags PurpleMessageFlags
  71 #include "purple-private.h"
  72
  73 /* Backward compatibility when compiling against 2.4.x API */
  74 #if !PURPLE_VERSION_CHECK(2,5,0) && !PURPLE_VERSION_CHECK(3,0,0)
  75 #define PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY 0x0100
  76 #endif
  77
  78 /*
  79  * NOTE: this flag means two things:
  80  *
  81  *  - is Single Sign-On supported, and
  82  *  - is Kerberos supported
  83  */
  84 #if defined(HAVE_LIBKRB5) || defined(HAVE_SSPI)
  85 #define PURPLE_SIPE_SSO_AND_KERBEROS 1
  86 #else
  87 #define PURPLE_SIPE_SSO_AND_KERBEROS 0
  88 #endif
  89
  90 /* Sipe core activity <-> Purple status mapping */
  91 static const gchar * const activity_to_purple_map[SIPE_ACTIVITY_NUM_TYPES] = {
  92 /* SIPE_ACTIVITY_UNSET       */ "unset",     /* == purple_primitive_get_id_from_type(PURPLE_STATUS_UNSET) */
  93 /* SIPE_ACTIVITY_AVAILABLE   */ "available", /* == purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE) */
  94 /* SIPE_ACTIVITY_ONLINE      */ "online",
  95 /* SIPE_ACTIVITY_INACTIVE    */ "idle",
  96 /* SIPE_ACTIVITY_BUSY        */ "busy",
  97 /* SIPE_ACTIVITY_BUSYIDLE    */ "busyidle",
  98 /* SIPE_ACTIVITY_DND         */ "do-not-disturb",
  99 /* SIPE_ACTIVITY_BRB         */ "be-right-back",
 100 /* SIPE_ACTIVITY_AWAY        */ "away",      /* == purple_primitive_get_id_from_type(PURPLE_STATUS_AWAY) */
 101 /* SIPE_ACTIVITY_LUNCH       */ "out-to-lunch",
 102 /* SIPE_ACTIVITY_INVISIBLE   */ "invisible", /* == purple_primitive_get_id_from_type(PURPLE_STATUS_INVISIBLE) */
 103 /* SIPE_ACTIVITY_OFFLINE     */ "offline",   /* == purple_primitive_get_id_from_type(PURPLE_STATUS_OFFLINE) */
 104 /* SIPE_ACTIVITY_ON_PHONE    */ "on-the-phone",
 105 /* SIPE_ACTIVITY_IN_CONF     */ "in-a-conference",
 106 /* SIPE_ACTIVITY_IN_MEETING  */ "in-a-meeting",
 107 /* SIPE_ACTIVITY_OOF         */ "out-of-office",
 108 /* SIPE_ACTIVITY_URGENT_ONLY */ "urgent-interruptions-only",
 109 };
 110
 111 GHashTable *purple_token_map;
 112
 113 static void sipe_purple_activity_init(void)
 114 {
 115         guint index;
 116
 117         purple_token_map = g_hash_table_new(g_str_hash, g_str_equal);
 118         for (index = SIPE_ACTIVITY_UNSET;
 119              index < SIPE_ACTIVITY_NUM_TYPES;
 120              index++) {
 121                 g_hash_table_insert(purple_token_map,
 122                                     (gchar *) activity_to_purple_map[index],
 123                                     GUINT_TO_POINTER(index));
 124         }
 125 }
 126
 127 static void sipe_purple_activity_shutdown(void)
 128 {
 129         g_hash_table_destroy(purple_token_map);
 130 }
 131
 132 const gchar *sipe_purple_activity_to_token(guint type)
 133 {
 134         return(activity_to_purple_map[type]);
 135 }
 136
 137 guint sipe_purple_token_to_activity(const gchar *token)
 138 {
 139         return(GPOINTER_TO_UINT(g_hash_table_lookup(purple_token_map, token)));
 140 }
 141
 142 gchar *sipe_backend_version(void)
 143 {
 144         return(g_strdup_printf("Purple/%s", purple_core_get_version()));
 145 }
 146
 147 /* PurplePluginProtocolInfo function calls & data structure */
 148 static const char *sipe_list_icon(SIPE_UNUSED_PARAMETER PurpleAccount *a,
 149                                   SIPE_UNUSED_PARAMETER PurpleBuddy *b)
 150 {
 151         return "sipe";
 152 }
 153
 154 static gchar *sipe_purple_status_text(PurpleBuddy *buddy)
 155 {
 156         const PurpleStatus *status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
 157         return sipe_core_buddy_status(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 158                                       buddy->name,
 159                                       sipe_purple_token_to_activity(purple_status_get_id(status)),
 160                                       purple_status_get_name(status));
 161 }
 162
 163 static void sipe_purple_tooltip_text(PurpleBuddy *buddy,
 164                                      PurpleNotifyUserInfo *user_info,
 165                                      SIPE_UNUSED_PARAMETER gboolean full)
 166 {
 167         const PurplePresence *presence = purple_buddy_get_presence(buddy);
 168         sipe_core_buddy_tooltip_info(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 169                                      buddy->name,
 170                                      purple_status_get_name(purple_presence_get_active_status(presence)),
 171                                      purple_presence_is_online(presence),
 172                                      (struct sipe_backend_buddy_tooltip *) user_info);
 173 }
 174
 175 static GList *sipe_purple_status_types(SIPE_UNUSED_PARAMETER PurpleAccount *acc)
 176 {
 177         PurpleStatusType *type;
 178         GList *types = NULL;
 179
 180         /* Macros to reduce code repetition.
 181            Translators: noun */
 182 #define SIPE_ADD_STATUS(prim,id,name,user) type = purple_status_type_new_with_attrs( \
 183                 prim, id, name,             \
 184                 TRUE, user, FALSE,          \
 185                 SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE, _("Message"), purple_value_new(PURPLE_TYPE_STRING), \
 186                 NULL);                      \
 187         types = g_list_append(types, type);
 188
 189         /* Online */
 190         SIPE_ADD_STATUS(PURPLE_STATUS_AVAILABLE,
 191                         NULL,
 192                         NULL,
 193                         TRUE);
 194
 195         /* Busy */
 196         SIPE_ADD_STATUS(PURPLE_STATUS_UNAVAILABLE,
 197                         sipe_purple_activity_to_token(SIPE_ACTIVITY_BUSY),
 198                         sipe_core_activity_description(SIPE_ACTIVITY_BUSY),
 199                         TRUE);
 200
 201         /* Do Not Disturb */
 202         SIPE_ADD_STATUS(PURPLE_STATUS_UNAVAILABLE,
 203                         sipe_purple_activity_to_token(SIPE_ACTIVITY_DND),
 204                         NULL,
 205                         TRUE);
 206
 207         /* In a call */
 208         SIPE_ADD_STATUS(PURPLE_STATUS_UNAVAILABLE,
 209                         sipe_purple_activity_to_token(SIPE_ACTIVITY_ON_PHONE),
 210                         sipe_core_activity_description(SIPE_ACTIVITY_ON_PHONE),
 211                         FALSE);
 212
 213         /* In a conference call  */
 214         SIPE_ADD_STATUS(PURPLE_STATUS_UNAVAILABLE,
 215                         sipe_purple_activity_to_token(SIPE_ACTIVITY_IN_CONF),
 216                         sipe_core_activity_description(SIPE_ACTIVITY_IN_CONF),
 217                         FALSE);
 218
 219         /* Away */
 220         /* Goes first in the list as
 221          * purple picks the first status with the AWAY type
 222          * for idle.
 223          */
 224         SIPE_ADD_STATUS(PURPLE_STATUS_AWAY,
 225                         NULL,
 226                         NULL,
 227                         TRUE);
 228
 229         /* Be Right Back */
 230         SIPE_ADD_STATUS(PURPLE_STATUS_AWAY,
 231                         sipe_purple_activity_to_token(SIPE_ACTIVITY_BRB),
 232                         sipe_core_activity_description(SIPE_ACTIVITY_BRB),
 233                         TRUE);
 234
 235         /* Appear Offline */
 236         SIPE_ADD_STATUS(PURPLE_STATUS_INVISIBLE,
 237                         NULL,
 238                         NULL,
 239                         TRUE);
 240
 241         /* Offline */
 242         type = purple_status_type_new(PURPLE_STATUS_OFFLINE,
 243                                       NULL,
 244                                       NULL,
 245                                       TRUE);
 246         types = g_list_append(types, type);
 247
 248         return types;
 249 }
 250
 251 static GList *sipe_purple_blist_node_menu(PurpleBlistNode *node)
 252 {
 253         if(PURPLE_BLIST_NODE_IS_BUDDY(node)) {
 254                 return sipe_purple_buddy_menu((PurpleBuddy *) node);
 255         } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) {
 256                 return sipe_purple_chat_menu((PurpleChat *)node);
 257         } else {
 258                 return NULL;
 259         }
 260 }
 261
 262 static guint get_authentication_type(PurpleAccount *account)
 263 {
 264         const gchar *auth = purple_account_get_string(account, "authentication", "ntlm");
 265
 266         /* map option list to type - default is NTLM */
 267         guint authentication_type = SIPE_AUTHENTICATION_TYPE_NTLM;
 268 #if PURPLE_SIPE_SSO_AND_KERBEROS
 269         if (sipe_strequal(auth, "krb5")) {
 270                 authentication_type = SIPE_AUTHENTICATION_TYPE_KERBEROS;
 271         }
 272 #endif
 273 #ifndef HAVE_SSPI
 274         /*
 275          * @TODO: SSL handshake support isn't implemented in sip-sec-sspi.c.
 276          *        So ignore configuration setting for now.
 277          */
 278         if (sipe_strequal(auth, "tls-dsk")) {
 279                 authentication_type = SIPE_AUTHENTICATION_TYPE_TLS_DSK;
 280         }
 281 #endif
 282
 283         return(authentication_type);
 284 }
 285
 286 static gboolean get_sso_flag(PurpleAccount *account)
 287 {
 288 #if PURPLE_SIPE_SSO_AND_KERBEROS
 289         /*
 290          * NOTE: the default must be *OFF*, i.e. it is up to the user to tell
 291          *       SIPE that it is OK to use Single Sign-On or not.
 292          */
 293         return(purple_account_get_bool(account, "sso", FALSE));
 294 #else
 295         return(FALSE);
 296 #endif
 297 }
 298
 299 static void connect_to_core(PurpleConnection *gc,
 300                             PurpleAccount *account,
 301                             const gchar *password)
 302 {
 303         const gchar *username  = purple_account_get_username(account);
 304         const gchar *email     = purple_account_get_string(account, "email", NULL);
 305         const gchar *email_url = purple_account_get_string(account, "email_url", NULL);
 306         const gchar *transport = purple_account_get_string(account, "transport", "auto");
 307         struct sipe_core_public *sipe_public;
 308         gchar **username_split;
 309         gchar *login_domain = NULL;
 310         gchar *login_account = NULL;
 311         const gchar *errmsg;
 312         guint transport_type;
 313         struct sipe_backend_private *purple_private;
 314
 315         /* username format: <username>,[<optional login>] */
 316         SIPE_DEBUG_INFO("sipe_purple_login: username '%s'", username);
 317         username_split = g_strsplit(username, ",", 2);
 318
 319         /* login name specified? */
 320         if (username_split[1] && strlen(username_split[1])) {
 321                 /* Allowed domain-account separators are / or \ */
 322                 gchar **domain_user = g_strsplit_set(username_split[1], "/\\", 2);
 323                 gboolean has_domain = domain_user[1] != NULL;
 324                 SIPE_DEBUG_INFO("sipe_purple_login: login '%s'", username_split[1]);
 325                 login_domain  = has_domain ? g_strdup(domain_user[0]) : NULL;
 326                 login_account = g_strdup(domain_user[has_domain ? 1 : 0]);
 327                 SIPE_DEBUG_INFO("sipe_purple_login: auth domain '%s' user '%s'",
 328                                 login_domain ? login_domain : "",
 329                                 login_account);
 330                 g_strfreev(domain_user);
 331         }
 332
 333         sipe_public = sipe_core_allocate(username_split[0],
 334                                          login_domain, login_account,
 335                                          password,
 336                                          email,
 337                                          email_url,
 338                                          &errmsg);
 339         g_free(login_domain);
 340         g_free(login_account);
 341         g_strfreev(username_split);
 342
 343         if (!sipe_public) {
 344 #if PURPLE_VERSION_CHECK(3,0,0)
 345                 purple_connection_error(
 346 #else
 347                 purple_connection_error_reason(
 348 #endif
 349                                                gc,
 350                                                PURPLE_CONNECTION_ERROR_INVALID_USERNAME,
 351                                                errmsg);
 352                 return;
 353         }
 354
 355         sipe_public->backend_private = purple_private = g_new0(struct sipe_backend_private, 1);
 356         purple_private->public = sipe_public;
 357         purple_private->gc = gc;
 358         purple_private->account = account;
 359
 360         sipe_purple_chat_setup_rejoin(purple_private);
 361
 362         SIPE_CORE_FLAG_UNSET(SSO);
 363         if (get_sso_flag(account))
 364                 SIPE_CORE_FLAG_SET(SSO);
 365
 366         gc->proto_data = sipe_public;
 367         gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_FORMATTING_WBFO | PURPLE_CONNECTION_NO_BGCOLOR |
 368                 PURPLE_CONNECTION_NO_FONTSIZE | PURPLE_CONNECTION_NO_URLDESC | PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY;
 369         purple_connection_set_display_name(gc, sipe_public->sip_name);
 370         purple_connection_update_progress(gc, _("Connecting"), 1, 2);
 371
 372         username_split = g_strsplit(purple_account_get_string(account, "server", ""), ":", 2);
 373
 374         /* The adium client requires a server string be supplied. If the user entered adium.im assume
 375           they really want autodiscovery */
 376         if (username_split[0] && sipe_strequal(username_split[0], "adium.im")) {
 377                 g_strfreev(username_split);
 378                 username_split = g_strsplit("", ":", 2);
 379         }
 380
 381         if (sipe_strequal(transport, "auto")) {
 382                 transport_type = (username_split[0] == NULL) ?
 383                         SIPE_TRANSPORT_AUTO : SIPE_TRANSPORT_TLS;
 384         } else if (sipe_strequal(transport, "tls")) {
 385                 transport_type = SIPE_TRANSPORT_TLS;
 386         } else {
 387                 transport_type = SIPE_TRANSPORT_TCP;
 388         }
 389         sipe_core_transport_sip_connect(sipe_public,
 390                                         transport_type,
 391                                         get_authentication_type(account),
 392                                         username_split[0],
 393                                         username_split[0] ? username_split[1] : NULL);
 394         g_strfreev(username_split);
 395 }
 396
 397 static void password_required_cb(PurpleConnection *gc,
 398                                  SIPE_UNUSED_PARAMETER PurpleRequestFields *fields)
 399 {
 400         if (!PURPLE_CONNECTION_IS_VALID(gc))
 401                 return;
 402
 403 #if PURPLE_VERSION_CHECK(3,0,0)
 404         purple_connection_error(
 405 #else
 406         purple_connection_error_reason(
 407 #endif
 408                                 gc,
 409                                 PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
 410                                 _("Password required"));
 411 }
 412
 413 static void password_ok_cb(PurpleConnection *gc,
 414                            PurpleRequestFields *fields)
 415 {
 416         const gchar *password;
 417
 418         if (!PURPLE_CONNECTION_IS_VALID(gc))
 419                 return;
 420
 421         password = purple_request_fields_get_string(fields, "password");
 422
 423         if (password && strlen(password)) {
 424                 PurpleAccount *account = purple_connection_get_account(gc);
 425
 426                 if (purple_request_fields_get_bool(fields, "remember"))
 427                         purple_account_set_remember_password(account, TRUE);
 428                 purple_account_set_password(account, password);
 429
 430                 /* Now we have a password and we can connect */
 431                 connect_to_core(gc, account, password);
 432
 433         } else
 434                 /* reject an empty password */
 435                 password_required_cb(gc, fields);
 436 }
 437
 438 static void sipe_purple_login(PurpleAccount *account)
 439 {
 440         PurpleConnection *gc = purple_account_get_connection(account);
 441         const gchar *password = purple_connection_get_password(gc);
 442
 443         /* Password required? */
 444         if (sipe_core_transport_sip_requires_password(get_authentication_type(account),
 445                                                       get_sso_flag(account)) &&
 446             (!password || !strlen(password)))
 447                 /* No password set - request one from user */
 448                 purple_account_request_password(account,
 449                                                 G_CALLBACK(password_ok_cb),
 450                                                 G_CALLBACK(password_required_cb),
 451                                                 gc);
 452         else
 453                 /* No password required or saved password - connect now */
 454                 connect_to_core(gc, account, password);
 455
 456 }
 457
 458 static void sipe_purple_close(PurpleConnection *gc)
 459 {
 460         struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
 461
 462         if (sipe_public) {
 463                 struct sipe_backend_private *purple_private = sipe_public->backend_private;
 464
 465                 sipe_core_deallocate(sipe_public);
 466
 467                 if (purple_private->roomlist_map)
 468                         g_hash_table_destroy(purple_private->roomlist_map);
 469                 sipe_purple_chat_destroy_rejoin(purple_private);
 470                 g_free(purple_private);
 471                 gc->proto_data = NULL;
 472         }
 473 }
 474
 475 static int sipe_purple_send_im(PurpleConnection *gc,
 476                                const char *who,
 477                                const char *what,
 478                                SIPE_UNUSED_PARAMETER PurpleMessageFlags flags)
 479 {
 480         sipe_core_im_send(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who, what);
 481         return 1;
 482 }
 483
 484 #define SIPE_TYPING_SEND_TIMEOUT 4
 485
 486 static unsigned int sipe_purple_send_typing(PurpleConnection *gc,
 487                                             const char *who,
 488                                             PurpleTypingState state)
 489 {
 490         if (state == PURPLE_NOT_TYPING)
 491                 return 0;
 492
 493         sipe_core_user_feedback_typing(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 494                                        who);
 495
 496         return SIPE_TYPING_SEND_TIMEOUT;
 497 }
 498
 499 static void sipe_purple_get_info(PurpleConnection *gc, const char *who)
 500 {
 501         sipe_core_buddy_get_info(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 502                                  who);
 503 }
 504
 505 static void sipe_purple_add_permit(PurpleConnection *gc, const char *name)
 506 {
 507         sipe_core_contact_allow_deny(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name, TRUE);
 508 }
 509
 510 static void sipe_purple_add_deny(PurpleConnection *gc, const char *name)
 511 {
 512         sipe_core_contact_allow_deny(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name, FALSE);
 513 }
 514
 515 static void sipe_purple_keep_alive(PurpleConnection *gc)
 516 {
 517         struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
 518         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 519         time_t now = time(NULL);
 520
 521         if ((sipe_public->keepalive_timeout > 0) &&
 522             ((guint) (now - purple_private->last_keepalive) >= sipe_public->keepalive_timeout) &&
 523             ((guint) (now - gc->last_received) >= sipe_public->keepalive_timeout)
 524                 ) {
 525                 sipe_core_transport_sip_keepalive(sipe_public);
 526                 purple_private->last_keepalive = now;
 527         }
 528 }
 529
 530 static void sipe_purple_alias_buddy(PurpleConnection *gc, const char *name,
 531                                     const char *alias)
 532 {
 533         sipe_core_group_set_alias(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name, alias);
 534 }
 535
 536 static void sipe_purple_group_rename(PurpleConnection *gc,
 537                                      const char *old_name,
 538                                      PurpleGroup *group,
 539                                      SIPE_UNUSED_PARAMETER GList *moved_buddies)
 540 {
 541         sipe_core_group_rename(PURPLE_GC_TO_SIPE_CORE_PUBLIC, old_name, group->name);
 542 }
 543
 544 static void sipe_purple_convo_closed(PurpleConnection *gc,
 545                                      const char *who)
 546 {
 547         sipe_core_im_close(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who);
 548 }
 549
 550 static void sipe_purple_group_remove(PurpleConnection *gc, PurpleGroup *group)
 551 {
 552         sipe_core_group_remove(PURPLE_GC_TO_SIPE_CORE_PUBLIC, group->name);
 553 }
 554
 555 #if PURPLE_VERSION_CHECK(2,5,0) || PURPLE_VERSION_CHECK(3,0,0)
 556 static GHashTable *
 557 sipe_purple_get_account_text_table(SIPE_UNUSED_PARAMETER PurpleAccount *account)
 558 {
 559         GHashTable *table;
 560         table = g_hash_table_new(g_str_hash, g_str_equal);
 561         g_hash_table_insert(table, "login_label", (gpointer)_("user@company.com"));
 562         return table;
 563 }
 564
 565 #if PURPLE_VERSION_CHECK(2,6,0) || PURPLE_VERSION_CHECK(3,0,0)
 566 #ifdef HAVE_VV
 567
 568 static void
 569 sipe_purple_sigusr1_handler(SIPE_UNUSED_PARAMETER int signum)
 570 {
 571         capture_pipeline("PURPLE_SIPE_PIPELINE");
 572 }
 573
 574 static gboolean sipe_purple_initiate_media(PurpleAccount *account, const char *who,
 575                                            SIPE_UNUSED_PARAMETER PurpleMediaSessionType type)
 576 {
 577         sipe_core_media_initiate_call(PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC,
 578                                       who,
 579                                       (type & PURPLE_MEDIA_VIDEO));
 580         return TRUE;
 581 }
 582
 583 static PurpleMediaCaps sipe_purple_get_media_caps(SIPE_UNUSED_PARAMETER PurpleAccount *account,
 584                                                   SIPE_UNUSED_PARAMETER const char *who)
 585 {
 586         return   PURPLE_MEDIA_CAPS_AUDIO
 587                | PURPLE_MEDIA_CAPS_AUDIO_VIDEO
 588                | PURPLE_MEDIA_CAPS_MODIFY_SESSION;
 589 }
 590 #endif
 591 #endif
 592 #endif
 593
 594 /*
 595  * Simplistic source upward compatibility path for newer libpurple APIs
 596  *
 597  * Usually we compile with -Werror=missing-field-initializers if GCC supports
 598  * it. But that means that the compilation of this structure can fail if the
 599  * newer API has added additional plugin callbacks. For the benefit of the
 600  * user we downgrade it to a warning here.
 601  *
 602  * Diagnostic #pragma was added in GCC 4.2.0
 603  * Diagnostic push/pop was added in GCC 4.6.0
 604  */
 605 #ifdef __GNUC__
 606 #if (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 2)
 607 #if __GNUC_MINOR__ >= 6
 608 #pragma GCC diagnostic push
 609 #endif
 610 #pragma GCC diagnostic warning "-Wmissing-field-initializers"
 611 #endif
 612 #endif
 613 static PurplePluginProtocolInfo sipe_prpl_info =
 614 {
 615 #if PURPLE_VERSION_CHECK(3,0,0)
 616         sizeof(PurplePluginProtocolInfo),       /* struct_size */
 617 #endif
 618         OPT_PROTO_CHAT_TOPIC |
 619         OPT_PROTO_PASSWORD_OPTIONAL,
 620         NULL,                                   /* user_splits */
 621         NULL,                                   /* protocol_options */
 622         NO_BUDDY_ICONS,                         /* icon_spec */
 623         sipe_list_icon,                         /* list_icon */
 624         NULL,                                   /* list_emblems */
 625         sipe_purple_status_text,                /* status_text */
 626         sipe_purple_tooltip_text,               /* tooltip_text */      // add custom info to contact tooltip
 627         sipe_purple_status_types,               /* away_states */
 628         sipe_purple_blist_node_menu,            /* blist_node_menu */
 629         sipe_purple_chat_info,                  /* chat_info */
 630         sipe_purple_chat_info_defaults,         /* chat_info_defaults */
 631         sipe_purple_login,                      /* login */
 632         sipe_purple_close,                      /* close */
 633         sipe_purple_send_im,                    /* send_im */
 634         NULL,                                   /* set_info */          // TODO maybe
 635         sipe_purple_send_typing,                /* send_typing */
 636         sipe_purple_get_info,                   /* get_info */
 637         sipe_purple_set_status,                 /* set_status */
 638         sipe_purple_set_idle,                   /* set_idle */
 639         NULL,                                   /* change_passwd */
 640         sipe_purple_add_buddy,                  /* add_buddy */
 641         NULL,                                   /* add_buddies */
 642         sipe_purple_remove_buddy,               /* remove_buddy */
 643         NULL,                                   /* remove_buddies */
 644         sipe_purple_add_permit,                 /* add_permit */
 645         sipe_purple_add_deny,                   /* add_deny */
 646         sipe_purple_add_deny,                   /* rem_permit */
 647         sipe_purple_add_permit,                 /* rem_deny */
 648         NULL,                                   /* set_permit_deny */
 649         sipe_purple_chat_join,                  /* join_chat */
 650         NULL,                                   /* reject_chat */
 651         NULL,                                   /* get_chat_name */
 652         sipe_purple_chat_invite,                /* chat_invite */
 653         sipe_purple_chat_leave,                 /* chat_leave */
 654         NULL,                                   /* chat_whisper */
 655         sipe_purple_chat_send,                  /* chat_send */
 656         sipe_purple_keep_alive,                 /* keepalive */
 657         NULL,                                   /* register_user */
 658         NULL,                                   /* get_cb_info */       // deprecated
 659 #if !PURPLE_VERSION_CHECK(3,0,0)
 660         NULL,                                   /* get_cb_away */       // deprecated
 661 #endif
 662         sipe_purple_alias_buddy,                /* alias_buddy */
 663         sipe_purple_group_buddy,                /* group_buddy */
 664         sipe_purple_group_rename,               /* rename_group */
 665         NULL,                                   /* buddy_free */
 666         sipe_purple_convo_closed,               /* convo_closed */
 667         purple_normalize_nocase,                /* normalize */
 668         NULL,                                   /* set_buddy_icon */
 669         sipe_purple_group_remove,               /* remove_group */
 670         NULL,                                   /* get_cb_real_name */  // TODO?
 671         NULL,                                   /* set_chat_topic */
 672         NULL,                                   /* find_blist_chat */
 673         sipe_purple_roomlist_get_list,          /* roomlist_get_list */
 674         sipe_purple_roomlist_cancel,            /* roomlist_cancel */
 675         NULL,                                   /* roomlist_expand_category */
 676         NULL,                                   /* can_receive_file */
 677         sipe_purple_ft_send_file,               /* send_file */
 678         sipe_purple_ft_new_xfer,                /* new_xfer */
 679         NULL,                                   /* offline_message */
 680         NULL,                                   /* whiteboard_prpl_ops */
 681         NULL,                                   /* send_raw */
 682         NULL,                                   /* roomlist_room_serialize */
 683         NULL,                                   /* unregister_user */
 684         NULL,                                   /* send_attention */
 685         NULL,                                   /* get_attention_types */
 686 #if !PURPLE_VERSION_CHECK(2,5,0) && !PURPLE_VERSION_CHECK(3,0,0)
 687         /* Backward compatibility when compiling against 2.4.x API */
 688         (void (*)(void))                        /* _purple_reserved4 */
 689 #endif
 690 #if !PURPLE_VERSION_CHECK(3,0,0)
 691         sizeof(PurplePluginProtocolInfo),       /* struct_size */
 692 #endif
 693 #if PURPLE_VERSION_CHECK(2,5,0) || PURPLE_VERSION_CHECK(3,0,0)
 694         sipe_purple_get_account_text_table,     /* get_account_text_table */
 695 #if PURPLE_VERSION_CHECK(2,6,0) || PURPLE_VERSION_CHECK(3,0,0)
 696 #ifdef HAVE_VV
 697         sipe_purple_initiate_media,             /* initiate_media */
 698         sipe_purple_get_media_caps,             /* get_media_caps */
 699 #else
 700         NULL,                                   /* initiate_media */
 701         NULL,                                   /* get_media_caps */
 702 #endif
 703 #if PURPLE_VERSION_CHECK(2,7,0) || PURPLE_VERSION_CHECK(3,0,0)
 704         NULL,                                   /* get_moods */
 705         NULL,                                   /* set_public_alias */
 706         NULL,                                   /* get_public_alias */
 707 #if PURPLE_VERSION_CHECK(2,8,0)
 708         NULL,                                   /* add_buddy_with_invite */
 709         NULL,                                   /* add_buddies_with_invite */
 710 #endif
 711 #endif
 712 #endif
 713 #endif
 714 };
 715 #ifdef __GNUC__
 716 #if (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 6)
 717 #pragma GCC diagnostic pop
 718 #endif
 719 #endif
 720 /* Original GCC error checking restored from here on... (see above) */
 721
 722 /* PurplePluginInfo function calls & data structure */
 723 static gboolean sipe_purple_plugin_load(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 724 {
 725 #ifdef HAVE_VV
 726         struct sigaction action;
 727         memset(&action, 0, sizeof (action));
 728         action.sa_handler = sipe_purple_sigusr1_handler;
 729         sigaction(SIGUSR1, &action, NULL);
 730 #endif
 731         return TRUE;
 732 }
 733
 734 static gboolean sipe_purple_plugin_unload(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 735 {
 736 #ifdef HAVE_VV
 737         struct sigaction action;
 738         memset(&action, 0, sizeof (action));
 739         action.sa_handler = SIG_DFL;
 740         sigaction(SIGUSR1, &action, NULL);
 741 #endif
 742         return TRUE;
 743 }
 744
 745 static void sipe_purple_plugin_destroy(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 746 {
 747         GList *entry;
 748
 749         sipe_purple_activity_shutdown();
 750         sipe_core_destroy();
 751
 752         entry = sipe_prpl_info.protocol_options;
 753         while (entry) {
 754                 purple_account_option_destroy(entry->data);
 755                 entry = g_list_delete_link(entry, entry);
 756         }
 757         sipe_prpl_info.protocol_options = NULL;
 758
 759         entry = sipe_prpl_info.user_splits;
 760         while (entry) {
 761                 purple_account_user_split_destroy(entry->data);
 762                 entry = g_list_delete_link(entry, entry);
 763         }
 764         sipe_prpl_info.user_splits = NULL;
 765 }
 766
 767 static void sipe_purple_show_about_plugin(PurplePluginAction *action)
 768 {
 769         gchar *tmp = sipe_core_about();
 770         purple_notify_formatted((PurpleConnection *) action->context,
 771                                 NULL, " ", NULL, tmp, NULL, NULL);
 772         g_free(tmp);
 773 }
 774
 775 static void sipe_purple_find_contact_cb(PurpleConnection *gc,
 776                                         PurpleRequestFields *fields)
 777 {
 778         GList *entries = purple_request_field_group_get_fields(purple_request_fields_get_groups(fields)->data);
 779         const gchar *given_name = NULL;
 780         const gchar *surname    = NULL;
 781         const gchar *email      = NULL;
 782         const gchar *company    = NULL;
 783         const gchar *country    = NULL;
 784
 785         while (entries) {
 786                 PurpleRequestField *field = entries->data;
 787                 const char *id = purple_request_field_get_id(field);
 788                 const char *value = purple_request_field_string_get_value(field);
 789
 790                 SIPE_DEBUG_INFO("sipe_purple_find_contact_cb: %s = '%s'", id, value ? value : "");
 791
 792                 if (value) {
 793                         if (strcmp(id, "given") == 0) {
 794                                 given_name = value;
 795                         } else if (strcmp(id, "surname") == 0) {
 796                                 surname = value;
 797                         } else if (strcmp(id, "email") == 0) {
 798                                 email = value;
 799                         } else if (strcmp(id, "company") == 0) {
 800                                 company = value;
 801                         } else if (strcmp(id, "country") == 0) {
 802                                 country = value;
 803                         }
 804                 }
 805
 806                 entries = g_list_next(entries);
 807         };
 808
 809         sipe_core_buddy_search(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 810                                NULL,
 811                                given_name,
 812                                surname,
 813                                email,
 814                                company,
 815                                country);
 816 }
 817
 818 static void sipe_purple_show_find_contact(PurplePluginAction *action)
 819 {
 820         PurpleConnection *gc = (PurpleConnection *) action->context;
 821         PurpleRequestFields *fields;
 822         PurpleRequestFieldGroup *group;
 823         PurpleRequestField *field;
 824
 825         fields = purple_request_fields_new();
 826         group = purple_request_field_group_new(NULL);
 827         purple_request_fields_add_group(fields, group);
 828
 829         field = purple_request_field_string_new("given", _("First name"), NULL, FALSE);
 830         purple_request_field_group_add_field(group, field);
 831         field = purple_request_field_string_new("surname", _("Last name"), NULL, FALSE);
 832         purple_request_field_group_add_field(group, field);
 833         field = purple_request_field_string_new("email", _("Email"), NULL, FALSE);
 834         purple_request_field_group_add_field(group, field);
 835         field = purple_request_field_string_new("company", _("Company"), NULL, FALSE);
 836         purple_request_field_group_add_field(group, field);
 837         field = purple_request_field_string_new("country", _("Country"), NULL, FALSE);
 838         purple_request_field_group_add_field(group, field);
 839
 840         purple_request_fields(gc,
 841                 _("Search"),
 842                 _("Search for a contact"),
 843                 _("Enter the information for the person you wish to find. Empty fields will be ignored."),
 844                 fields,
 845                 _("_Search"), G_CALLBACK(sipe_purple_find_contact_cb),
 846                 _("_Cancel"), NULL,
 847                 purple_connection_get_account(gc), NULL, NULL, gc);
 848 }
 849
 850 static void sipe_purple_join_conference_cb(PurpleConnection *gc,
 851                                            PurpleRequestFields *fields)
 852 {
 853         GList *entries = purple_request_field_group_get_fields(purple_request_fields_get_groups(fields)->data);
 854
 855         if (entries) {
 856                 PurpleRequestField *field = entries->data;
 857                 const char *id = purple_request_field_get_id(field);
 858                 const char *value = purple_request_field_string_get_value(field);
 859
 860                 if (!sipe_strequal(id, "meetingLocation"))
 861                         return;
 862
 863                 sipe_core_conf_create(PURPLE_GC_TO_SIPE_CORE_PUBLIC, value);
 864         }
 865 }
 866
 867 #ifdef HAVE_VV
 868 static void sipe_purple_test_call(PurplePluginAction *action)
 869 {
 870         PurpleConnection *gc = (PurpleConnection *) action->context;
 871         sipe_core_media_test_call(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 872 }
 873 #endif
 874
 875 static void sipe_purple_show_join_conference(PurplePluginAction *action)
 876 {
 877         PurpleConnection *gc = (PurpleConnection *) action->context;
 878         PurpleRequestFields *fields;
 879         PurpleRequestFieldGroup *group;
 880         PurpleRequestField *field;
 881
 882         fields = purple_request_fields_new();
 883         group = purple_request_field_group_new(NULL);
 884         purple_request_fields_add_group(fields, group);
 885
 886         field = purple_request_field_string_new("meetingLocation", _("Meeting location"), NULL, FALSE);
 887         purple_request_field_group_add_field(group, field);
 888
 889         purple_request_fields(gc,
 890                 _("Join conference"),
 891                 _("Join scheduled conference"),
 892                 _("Enter meeting location string you received in the invitation.\n"
 893                   "\n"
 894                   "Valid location will be something like\n"
 895                   "meet:sip:someone@company.com;gruu;opaque=app:conf:focus:id:abcdef1234\n"
 896                   "conf:sip:someone@company.com;gruu;opaque=app:conf:focus:id:abcdef1234\n"
 897                   "or\n"
 898                   "https://meet.company.com/someone/abcdef1234"),
 899                 fields,
 900                 _("_Join"), G_CALLBACK(sipe_purple_join_conference_cb),
 901                 _("_Cancel"), NULL,
 902                 purple_connection_get_account(gc), NULL, NULL, gc);
 903 }
 904
 905 static void sipe_purple_republish_calendar(PurplePluginAction *action)
 906 {
 907         PurpleConnection *gc = (PurpleConnection *) action->context;
 908         sipe_core_update_calendar(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 909 }
 910
 911 static void sipe_purple_reset_status(PurplePluginAction *action)
 912 {
 913         PurpleConnection *gc = (PurpleConnection *) action->context;
 914         sipe_core_reset_status(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 915 }
 916
 917 static GList *sipe_purple_actions(SIPE_UNUSED_PARAMETER PurplePlugin *plugin,
 918                                   SIPE_UNUSED_PARAMETER gpointer context)
 919 {
 920         GList *menu = NULL;
 921         PurplePluginAction *act;
 922
 923         act = purple_plugin_action_new(_("About SIPE plugin..."), sipe_purple_show_about_plugin);
 924         menu = g_list_prepend(menu, act);
 925
 926         act = purple_plugin_action_new(_("Contact search..."), sipe_purple_show_find_contact);
 927         menu = g_list_prepend(menu, act);
 928
 929 #ifdef HAVE_VV
 930         act = purple_plugin_action_new(_("Test call"), sipe_purple_test_call);
 931         menu = g_list_prepend(menu, act);
 932 #endif
 933
 934         act = purple_plugin_action_new(_("Join scheduled conference..."), sipe_purple_show_join_conference);
 935         menu = g_list_prepend(menu, act);
 936
 937         act = purple_plugin_action_new(_("Republish Calendar"), sipe_purple_republish_calendar);
 938         menu = g_list_prepend(menu, act);
 939
 940         act = purple_plugin_action_new(_("Reset status"), sipe_purple_reset_status);
 941         menu = g_list_prepend(menu, act);
 942
 943         return g_list_reverse(menu);
 944 }
 945
 946 static PurplePluginInfo sipe_purple_info = {
 947         PURPLE_PLUGIN_MAGIC,
 948         PURPLE_MAJOR_VERSION,
 949         PURPLE_MINOR_VERSION,
 950         PURPLE_PLUGIN_PROTOCOL,                           /**< type           */
 951         NULL,                                             /**< ui_requirement */
 952         0,                                                /**< flags          */
 953         NULL,                                             /**< dependencies   */
 954         PURPLE_PRIORITY_DEFAULT,                          /**< priority       */
 955         "prpl-sipe",                                      /**< id             */
 956         "Office Communicator",                            /**< name           */
 957         PACKAGE_VERSION,                                  /**< version        */
 958         "Microsoft Office Communicator Protocol Plugin",  /**< summary        */
 959         "A plugin for the extended SIP/SIMPLE protocol used by "          /**< description */
 960         "Microsoft Live/Office Communications Server (LCS2005/OCS2007+)", /**< description */
 961         "Anibal Avelar <avelar@gmail.com>, "              /**< author         */
 962         "Gabriel Burt <gburt@novell.com>, "               /**< author         */
 963         "Stefan Becker <stefan.becker@nokia.com>, "       /**< author         */
 964         "pier11 <pier11@operamail.com>",                  /**< author         */
 965         PACKAGE_URL,                                      /**< homepage       */
 966         sipe_purple_plugin_load,                          /**< load           */
 967         sipe_purple_plugin_unload,                        /**< unload         */
 968         sipe_purple_plugin_destroy,                       /**< destroy        */
 969         NULL,                                             /**< ui_info        */
 970         &sipe_prpl_info,                                  /**< extra_info     */
 971         NULL,
 972         sipe_purple_actions,
 973         NULL,
 974         NULL,
 975         NULL,
 976         NULL
 977 };
 978
 979 static void sipe_purple_init_plugin(PurplePlugin *plugin)
 980 {
 981         PurpleAccountUserSplit *split;
 982         PurpleAccountOption *option;
 983
 984         /* This needs to be called first */
 985         sipe_core_init(LOCALEDIR);
 986         sipe_purple_activity_init();
 987
 988         purple_plugin_register(plugin);
 989
 990         /**
 991          * When adding new string settings please make sure to keep these
 992          * in sync:
 993          *
 994          *     api/sipe-backend.h
 995          *     purple-settings.c:setting_name[]
 996          */
 997         split = purple_account_user_split_new(_("Login\n   user  or  DOMAIN\\user  or\n   user@company.com"), NULL, ',');
 998         purple_account_user_split_set_reverse(split, FALSE);
 999         sipe_prpl_info.user_splits = g_list_append(sipe_prpl_info.user_splits, split);
1000
1001         option = purple_account_option_string_new(_("Server[:Port]\n(leave empty for auto-discovery)"), "server", "");
1002         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1003
1004         option = purple_account_option_list_new(_("Connection type"), "transport", NULL);
1005         purple_account_option_add_list_item(option, _("Auto"), "auto");
1006         purple_account_option_add_list_item(option, _("SSL/TLS"), "tls");
1007         purple_account_option_add_list_item(option, _("TCP"), "tcp");
1008         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1009
1010         /*option = purple_account_option_bool_new(_("Publish status (note: everyone may watch you)"), "doservice", TRUE);
1011         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);*/
1012
1013         option = purple_account_option_string_new(_("User Agent"), "useragent", "");
1014         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1015
1016         option = purple_account_option_list_new(_("Authentication scheme"), "authentication", NULL);
1017         purple_account_option_add_list_item(option, _("NTLM"), "ntlm");
1018 #if PURPLE_SIPE_SSO_AND_KERBEROS
1019         purple_account_option_add_list_item(option, _("Kerberos"), "krb5");
1020 #endif
1021 #ifndef HAVE_SSPI
1022         /* see above */
1023         purple_account_option_add_list_item(option, _("TLS-DSK"), "tls-dsk");
1024 #endif
1025         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1026
1027 #if PURPLE_SIPE_SSO_AND_KERBEROS
1028         /*
1029          * When the user selects Single Sign-On then SIPE will ignore the
1030          * settings for "login name" and "password". Instead it will use the
1031          * default credentials provided by the OS.
1032          *
1033          * NOTE: the default must be *OFF*, i.e. it is up to the user to tell
1034          *       SIPE that it is OK to use Single Sign-On or not.
1035          *
1036          * Configurations that are known to support Single Sign-On:
1037          *
1038          *  - Windows, host joined to domain, SIPE with SSPI: NTLM
1039          *  - Windows, host joined to domain, SIPE with SSPI: Kerberos
1040          *  - SIPE with libkrb5, valid TGT in cache (kinit):  Kerberos
1041          */
1042         option = purple_account_option_bool_new(_("Use Single Sign-On"), "sso", FALSE);
1043         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1044 #endif
1045
1046         /** Example (Exchange): https://server.company.com/EWS/Exchange.asmx
1047          *  Example (Domino)  : https://[domino_server]/[mail_database_name].nsf
1048          */
1049         option = purple_account_option_string_new(_("Email services URL\n(leave empty for auto-discovery)"), "email_url", "");
1050         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1051
1052         option = purple_account_option_string_new(_("Email address\n(if different from Username)"), "email", "");
1053         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1054
1055         /** Example (Exchange): DOMAIN\user  or  user@company.com
1056          *  Example (Domino)  : email_address
1057          */
1058         option = purple_account_option_string_new(_("Email login\n(if different from Login)"), "email_login", "");
1059         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1060
1061         option = purple_account_option_string_new(_("Email password\n(if different from Password)"), "email_password", "");
1062 #if PURPLE_VERSION_CHECK(3,0,0)
1063         purple_account_option_string_set_masked(
1064 #else
1065         purple_account_option_set_masked(
1066 #endif
1067                                          option, TRUE);
1068         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1069
1070         /** Example (federated domain): company.com      (i.e. ocschat@company.com)
1071          *  Example (non-default user): user@company.com
1072          */
1073         option = purple_account_option_string_new(_("Group Chat Proxy\n   company.com  or  user@company.com\n(leave empty to determine from Username)"), "groupchat_user", "");
1074         sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
1075 }
1076
1077 /* This macro makes the code a purple plugin */
1078 PURPLE_INIT_PLUGIN(sipe, sipe_purple_init_plugin, sipe_purple_info);
1079
1080 /*
1081   Local Variables:
1082   mode: c
1083   c-file-style: "bsd"
1084   indent-tabs-mode: t
1085   tab-width: 8
1086   End:
1087 */