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(NULL, NULL, 0, 0, NULL, NULL)
 163         };
 164
 165         return(sipe_parameters);
 166 }
 167
 168 /* non-static, because it is re-used by connection object */
 169 gchar *sipe_telepathy_protocol_normalize_contact(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 170                                                  const gchar *contact,
 171                                                  GError **error)
 172 {
 173         gchar *uri = sip_uri_if_valid(contact);
 174
 175         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::normalize_contact");
 176
 177         if (!uri)
 178                 g_set_error(error, TP_ERROR, TP_ERROR_INVALID_HANDLE,
 179                             _("User name should be a valid SIP URI\nExample: user@company.com"));
 180         return(uri);
 181 }
 182
 183 static gchar *identify_account(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 184                                GHashTable *asv,
 185                                SIPE_UNUSED_PARAMETER GError **error)
 186 {
 187         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::identify_account");
 188
 189         return(g_strdup(tp_asv_get_string(asv, "account")));
 190 }
 191
 192 static GStrv get_interfaces(SIPE_UNUSED_PARAMETER TpBaseProtocol *base)
 193 {
 194         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::get_interfaces");
 195
 196         return(g_new0(gchar *, 1));
 197 }
 198
 199 static void get_connection_details(SIPE_UNUSED_PARAMETER TpBaseProtocol *self,
 200                                    GStrv *connection_interfaces,
 201                                    GType **channel_managers,
 202                                    gchar **icon_name,
 203                                    gchar **english_name,
 204                                    gchar **vcard_field)
 205 {
 206         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::get_connection_details");
 207
 208         if (connection_interfaces) {
 209                 static const gchar * const interfaces[] = {
 210                         /* @TODO */
 211                         NULL
 212                 };
 213                 *connection_interfaces = g_strdupv((GStrv) interfaces);
 214         }
 215         if (channel_managers) {
 216                 GType types[] = {
 217                         /* @TODO */
 218                         TP_TYPE_SIMPLE_PASSWORD_MANAGER,
 219                         G_TYPE_INVALID
 220                 };
 221                 *channel_managers = g_memdup(types, sizeof(types));
 222         }
 223         if (icon_name)
 224                 *icon_name    = g_strdup("im-" SIPE_TELEPATHY_DOMAIN);
 225         if (english_name)
 226                 *english_name = g_strdup("Office Communicator");
 227         if (vcard_field)
 228                 *vcard_field  = g_strdup("x-" SIPE_TELEPATHY_DOMAIN);
 229 }
 230
 231 static GStrv dup_authentication_types(SIPE_UNUSED_PARAMETER TpBaseProtocol *self)
 232 {
 233         static const gchar * const types[] = {
 234                 /* @TODO */
 235                 NULL
 236         };
 237
 238         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::dup_authentication_types");
 239
 240         return(g_strdupv((GStrv) types));
 241 }
 242
 243 /*
 244  * Protocol class - type implementation
 245  */
 246 static void sipe_protocol_class_init(SipeProtocolClass *klass)
 247 {
 248         TpBaseProtocolClass *base_class = (TpBaseProtocolClass *) klass;
 249
 250         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::class_init");
 251
 252         base_class->get_parameters           = get_parameters;
 253         base_class->new_connection           = sipe_telepathy_connection_new;
 254         base_class->normalize_contact        = sipe_telepathy_protocol_normalize_contact;
 255         base_class->identify_account         = identify_account;
 256         base_class->get_interfaces           = get_interfaces;
 257         base_class->get_connection_details   = get_connection_details;
 258         base_class->dup_authentication_types = dup_authentication_types;
 259 }
 260
 261 static void sipe_protocol_init(SIPE_UNUSED_PARAMETER SipeProtocol *self)
 262 {
 263         SIPE_DEBUG_INFO_NOFORMAT("SipeProtocol::init");
 264 }
 265
 266 /* add protocol to connection manager */
 267 void sipe_telepathy_protocol_init(TpBaseConnectionManager *cm)
 268 {
 269         TpBaseProtocol *protocol = g_object_new(SIPE_TYPE_PROTOCOL,
 270                                                 "name", SIPE_TELEPATHY_DOMAIN,
 271                                                 NULL);
 272         tp_base_connection_manager_add_protocol(cm, protocol);
 273         g_object_unref(protocol);
 274 }
 275
 276
 277 /*
 278   Local Variables:
 279   mode: c
 280   c-file-style: "bsd"
 281   indent-tabs-mode: t
 282   tab-width: 8
 283   End:
 284 */