src/telepathy/telepathy-protocol.c

   1 /**
   2  * @file telepathy-protocol.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2012 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
  29 #include <dbus/dbus-protocol.h>
  30 #include <glib-object.h>
  31 #include <telepathy-glib/base-connection-manager.h>
  32 #include <telepathy-glib/base-protocol.h>
  33 #include <telepathy-glib/simple-password-manager.h>
  34 #include <telepathy-glib/telepathy-glib.h>
  35
  36 #include "sipe-backend.h"
  37 #include "sipe-common.h"
  38 #include "sipe-core.h"
  39 #include "sipe-nls.h"
  40
  41 #include "telepathy-private.h"
  42
  43 G_BEGIN_DECLS
  44 /*
  45  * Protocol class - data structures
  46  */
  47 typedef struct _SipeProtocolClass {
  48         TpBaseProtocolClass parent_class;
  49 } SipeProtocolClass;
  50
  51 typedef struct _SipeProtocol {
  52         TpBaseProtocol parent;
  53 } SipeProtocol;
  54
  55 /*
  56  * Protocol class - type macros
  57  */
  58 static GType sipe_protocol_get_type(void) G_GNUC_CONST;
  59 #define SIPE_TYPE_PROTOCOL \
  60         (sipe_protocol_get_type())
  61 #define SIPE_PROTOCOL(obj) \
  62         (G_TYPE_CHECK_INSTANCE_CAST((obj), SIPE_TYPE_PROTOCOL, \
  63                                     SipeProtocol))
  64 G_END_DECLS
  65
  66 /*
  67  * Protocol class - type definition
  68  */
  69 G_DEFINE_TYPE(SipeProtocol,
  70               sipe_protocol,
  71               TP_TYPE_BASE_PROTOCOL)
  72
  73 /*
  74  * Protocol class - instance methods
  75  */
  76 /*
  77  * @TODO: parameter filtering doesn't seem to work: these functions aren't
  78  *        called at all - why?
  79  */
  80 static gboolean parameter_filter_account(SIPE_UNUSED_PARAMETER const TpCMParamSpec *paramspec,
  81                                          GValue *value,
  82                                          GError **error)
  83 {
  84         const gchar *str = g_value_get_string(value);
  85
  86         if ((str == NULL) ||
  87             (strchr(str, '@') == NULL)) {
  88                 g_set_error(error, TP_ERROR, TP_ERROR_INVALID_HANDLE,
  89                             _("User name should be a valid SIP URI\nExample: user@company.com"));
  90                 return(FALSE);
  91         }
  92         return(TRUE);
  93 }
  94
  95 static const TpCMParamSpec *get_parameters(SIPE_UNUSED_PARAMETER TpBaseProtocol *self)
  96 {
  97 /* ISO C99 Designated Initializers silences -Wmissing-field-initializers */
  98 #define SIPE_PROTOCOL_PARAMETER(_name, _dtype, _gtype, _flags, _default, _filter) \
  99         {                                  \
 100                 .name        = (_name),    \
 101                 .dtype       = (_dtype),   \
 102                 .gtype       = (_gtype),   \
 103                 .flags       = (_flags),   \
 104                 .def         = (_default), \
 105                 .offset      = 0,          \
 106                 .filter      = (_filter),  \
 107                 .filter_data = NULL,       \
 108                 .setter_data = NULL,       \
 109         }
 110
 111         static const TpCMParamSpec const sipe_parameters[] = {
 112                 SIPE_PROTOCOL_PARAMETER("account",
 113                                         DBUS_TYPE_STRING_AS_STRING,
 114                                         G_TYPE_STRING,
 115                                         TP_CONN_MGR_PARAM_FLAG_REQUIRED,
 116                                         NULL,
 117                                         parameter_filter_account),
 118                 SIPE_PROTOCOL_PARAMETER("login",
 119                                         DBUS_TYPE_STRING_AS_STRING,
 120                                         G_TYPE_STRING,
 121                                         TP_CONN_MGR_PARAM_FLAG_REQUIRED,
 122                                         NULL,
 123                                         tp_cm_param_filter_string_nonempty),
 124                 SIPE_PROTOCOL_PARAMETER("password",
 125                                         DBUS_TYPE_STRING_AS_STRING,
 126                                         G_TYPE_STRING,
 127                                         TP_CONN_MGR_PARAM_FLAG_SECRET,
 128                                         NULL,
 129                                         NULL /* can be empty */),
 130                 SIPE_PROTOCOL_PARAMETER("server",
 131                                         DBUS_TYPE_STRING_AS_STRING,
 132                                         G_TYPE_STRING,
 133                                         0,
 134                                         NULL,
 135                                         NULL /* can be empty */),
 136                 SIPE_PROTOCOL_PARAMETER("port",
 137                                         DBUS_TYPE_UINT16_AS_STRING,
 138                                         G_TYPE_UINT,
 139                                         TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT,
 140                                         GUINT_TO_POINTER(0),
 141                                         NULL),
 142                 /* @TODO: this should be combo auto/ssl/tcp */
 143                 SIPE_PROTOCOL_PARAMETER("transport",
 144                                         DBUS_TYPE_STRING_AS_STRING,
 145                                         G_TYPE_STRING,
 146                                         TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT,
 147                                         "auto",
 148                                         tp_cm_param_filter_string_nonempty),
 149                 SIPE_PROTOCOL_PARAMETER("useragent",
 150                                         DBUS_TYPE_STRING_AS_STRING,
 151                                         G_TYPE_STRING,
 152                                         0,
 153                                         NULL,
 154                                         NULL /* can be empty */),
 155                 /* @TODO: this should be combo ntlm/krb5/tls-dsk */
 156                 SIPE_PROTOCOL_PARAMETER("authentication",
 157                                         DBUS_TYPE_STRING_AS_STRING,
 158                                         G_TYPE_STRING,
 159                                         TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT,
 160                                         "ntlm",
 161                                         tp_cm_param_filter_string_nonempty),
 162                 SIPE_PROTOCOL_PARAMETER("single-sign-on",
 163                                         DBUS_TYPE_BOOLEAN_AS_STRING,
 164                                         G_TYPE_BOOLEAN,
 165                                         TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT,
 166                                         GINT_TO_POINTER(FALSE),
 167                                         NULL),
 168                 SIPE_PROTOCOL_PARAMETER("don't-publish-calendar",
 169                                         DBUS_TYPE_BOOLEAN_AS_STRING,
 170                                         G_TYPE_BOOLEAN,
 171                                         TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT,
 172                                         GINT_TO_POINTER(FALSE),
 173                                         NULL),
 174                 SIPE_PROTOCOL_PARAMETER(NULL, NULL, 0, 0, NULL, NULL)
 175         };
 176
 177         return(sipe_parameters);
 178 }
 179
 180 /* non-static, because it is re-used by connection object */
 181 gchar *sipe_telepathy_protocol_normalize_contact(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 182                                                  const gchar *contact,
 183                                                  GError **error)
 184 {
 185         gchar *uri = sip_uri_if_valid(contact);
 186
 187         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::normalize_contact");
 188
 189         if (!uri)
 190                 g_set_error(error, TP_ERROR, TP_ERROR_INVALID_HANDLE,
 191                             _("User name should be a valid SIP URI\nExample: user@company.com"));
 192         return(uri);
 193 }
 194
 195 static gchar *identify_account(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 196                                GHashTable *asv,
 197                                SIPE_UNUSED_PARAMETER GError **error)
 198 {
 199         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::identify_account");
 200
 201         return(g_strdup(tp_asv_get_string(asv, "account")));
 202 }
 203
 204 static GStrv get_interfaces(SIPE_UNUSED_PARAMETER TpBaseProtocol *base)
 205 {
 206         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::get_interfaces");
 207
 208         return(g_new0(gchar *, 1));
 209 }
 210
 211 static void get_connection_details(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 212                                    GStrv *connection_interfaces,
 213                                    GType **channel_managers,
 214                                    gchar **icon_name,
 215                                    gchar **english_name,
 216                                    gchar **vcard_field)
 217 {
 218         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::get_connection_details");
 219
 220         if (connection_interfaces) {
 221                 static const gchar * const interfaces[] = {
 222                         /* @TODO */
 223                         NULL
 224                 };
 225                 *connection_interfaces = g_strdupv((GStrv) interfaces);
 226         }
 227         if (channel_managers) {
 228                 GType types[] = {
 229                         /* @TODO */
 230                         TP_TYPE_SIMPLE_PASSWORD_MANAGER,
 231                         SIPE_TYPE_SEARCH_MANAGER,
 232                         G_TYPE_INVALID
 233                 };
 234                 *channel_managers = g_memdup(types, sizeof(types));
 235         }
 236         if (icon_name)
 237                 *icon_name    = g_strdup("im-" SIPE_TELEPATHY_DOMAIN);
 238         if (english_name)
 239                 *english_name = g_strdup("Office Communicator");
 240         if (vcard_field)
 241                 *vcard_field  = g_strdup("x-" SIPE_TELEPATHY_DOMAIN);
 242 }
 243
 244 static GStrv dup_authentication_types(SIPE_UNUSED_PARAMETER TpBaseProtocol *self)
 245 {
 246         static const gchar * const types[] = {
 247                 /* @TODO */
 248                 NULL
 249         };
 250
 251         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::dup_authentication_types");
 252
 253         return(g_strdupv((GStrv) types));
 254 }
 255
 256 /*
 257  * Protocol class - type implementation
 258  */
 259 static void sipe_protocol_class_init(SipeProtocolClass *klass)
 260 {
 261         TpBaseProtocolClass *base_class = TP_BASE_PROTOCOL_CLASS(klass);
 262
 263         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::class_init");
 264
 265         base_class->get_parameters           = get_parameters;
 266         base_class->new_connection           = sipe_telepathy_connection_new;
 267         base_class->normalize_contact        = sipe_telepathy_protocol_normalize_contact;
 268         base_class->identify_account         = identify_account;
 269         base_class->get_interfaces           = get_interfaces;
 270         base_class->get_connection_details   = get_connection_details;
 271         base_class->dup_authentication_types = dup_authentication_types;
 272 }
 273
 274 static void sipe_protocol_init(SIPE_UNUSED_PARAMETER SipeProtocol *self)
 275 {
 276         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::init");
 277 }
 278
 279 /* add protocol to connection manager */
 280 void sipe_telepathy_protocol_init(TpBaseConnectionManager *cm)
 281 {
 282         TpBaseProtocol *protocol = g_object_new(SIPE_TYPE_PROTOCOL,
 283                                                 "name", SIPE_TELEPATHY_DOMAIN,
 284                                                 NULL);
 285         tp_base_connection_manager_add_protocol(cm, protocol);
 286         g_object_unref(protocol);
 287 }
 288
 289
 290 /*
 291   Local Variables:
 292   mode: c
 293   c-file-style: "bsd"
 294   indent-tabs-mode: t
 295   tab-width: 8
 296   End:
 297 */