git.maemo.org Git - modest/blob - src/modest-protocol-registry.c

   1 /* Copyright (c) 2007, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <string.h>
  31 #include <modest-account-protocol.h>
  32 #include <modest-defs.h>
  33 #include <modest-protocol-registry.h>
  34 #include <tny-camel-pop-store-account.h>
  35 #include <tny-camel-imap-store-account.h>
  36 #include <tny-camel-store-account.h>
  37 #include <tny-camel-transport-account.h>
  38 #include <tny-simple-list.h>
  39
  40 #define TAG_ALL_PROTOCOLS "__MODEST_PROTOCOL_REGISTRY_ALL_PROTOCOLS"
  41
  42 /* These seem to be listed in
  43  * libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c
  44  */
  45 #define MODEST_ACCOUNT_OPTION_SSL_NEVER "never"
  46 /* This is a tinymail camel-lite specific option,
  47  * roughly equivalent to "always" in regular camel,
  48  * which is appropriate for a generic "SSL" connection option: */
  49 #define MODEST_ACCOUNT_OPTION_SSL_WRAPPED "wrapped"
  50 /* Not used in our UI so far: */
  51 #define MODEST_ACCOUNT_OPTION_SSL_WHEN_POSSIBLE "when-possible"
  52 /* This is a tinymailcamel-lite specific option that is not in regular camel. */
  53 #define MODEST_ACCOUNT_OPTION_SSL_TLS "tls"
  54
  55 /* Posssible values for tny_account_set_secure_auth_mech().
  56  * These might be camel-specific.
  57  * Really, tinymail should use an enum.
  58  * camel_sasl_authtype() seems to list some possible values.
  59  */
  60
  61 /* Note that evolution does not offer these for IMAP: */
  62 #define MODEST_ACCOUNT_AUTH_PLAIN "PLAIN"
  63 #define MODEST_ACCOUNT_AUTH_ANONYMOUS "ANONYMOUS"
  64
  65 /* Caeml's IMAP uses NULL instead for "Password".
  66  * Also, not that Evolution offers "Password" for IMAP, but "Login" for SMTP.*/
  67 #define MODEST_ACCOUNT_AUTH_PASSWORD "LOGIN"
  68 #define MODEST_ACCOUNT_AUTH_CRAMMD5 "CRAM-MD5"
  69
  70 /* These seem to be listed in
  71  * libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-provider.c
  72  */
  73 #define MODEST_ACCOUNT_OPTION_USE_LSUB "use_lsub" /* Show only subscribed folders */
  74 #define MODEST_ACCOUNT_OPTION_CHECK_ALL "check_all" /* Check for new messages in all folders */
  75
  76 /* 'private'/'protected' functions */
  77 static void   modest_protocol_registry_class_init (ModestProtocolRegistryClass *klass);
  78 static void   modest_protocol_registry_finalize   (GObject *obj);
  79 static void   modest_protocol_registry_instance_init (ModestProtocolRegistry *obj);
  80 static GHashTable *   modest_protocol_registry_create_tag (ModestProtocolRegistry *obj, const gchar *tag);
  81
  82 /* translation handlers */
  83 static gchar * translation_is_userdata (gpointer userdata, ...);
  84
  85 typedef struct _ModestProtocolRegistryPrivate ModestProtocolRegistryPrivate;
  86 struct _ModestProtocolRegistryPrivate {
  87         GHashTable *tags_table;
  88         GHashTable *priorities;
  89 };
  90
  91 #define MODEST_PROTOCOL_REGISTRY_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  92                                                                          MODEST_TYPE_PROTOCOL_REGISTRY, \
  93                                                                          ModestProtocolRegistryPrivate))
  94
  95 /* globals */
  96 static GObjectClass *parent_class = NULL;
  97
  98 static ModestProtocolType pop_protocol_type_id = -1;
  99 static ModestProtocolType imap_protocol_type_id = -1;
 100 static ModestProtocolType maildir_protocol_type_id = -1;
 101 static ModestProtocolType mbox_protocol_type_id = -1;
 102 static ModestProtocolType smtp_protocol_type_id = -1;
 103 static ModestProtocolType sendmail_protocol_type_id = -1;
 104 static ModestProtocolType none_connection_protocol_type_id = -1;
 105 static ModestProtocolType ssl_connection_protocol_type_id = -1;
 106 static ModestProtocolType tls_connection_protocol_type_id = -1;
 107 static ModestProtocolType tlsop_connection_protocol_type_id = -1;
 108 static ModestProtocolType none_auth_protocol_type_id = -1;
 109 static ModestProtocolType password_auth_protocol_type_id = -1;
 110 static ModestProtocolType crammd5_auth_protocol_type_id = -1;
 111
 112 GType
 113 modest_protocol_registry_get_type (void)
 114 {
 115         static GType my_type = 0;
 116
 117         if (!my_type) {
 118                 static const GTypeInfo my_info = {
 119                         sizeof(ModestProtocolRegistryClass),
 120                         NULL,   /* base init */
 121                         NULL,   /* base finalize */
 122                         (GClassInitFunc) modest_protocol_registry_class_init,
 123                         NULL,   /* class finalize */
 124                         NULL,   /* class data */
 125                         sizeof(ModestProtocolRegistry),
 126                         0,      /* n_preallocs */
 127                         (GInstanceInitFunc) modest_protocol_registry_instance_init,
 128                         NULL
 129                 };
 130
 131                 my_type = g_type_register_static (G_TYPE_OBJECT,
 132                                                   "ModestProtocolRegistry",
 133                                                   &my_info, 0);
 134         }
 135         return my_type;
 136 }
 137
 138 static void
 139 modest_protocol_registry_class_init (ModestProtocolRegistryClass *klass)
 140 {
 141         GObjectClass *object_class;
 142         object_class = (GObjectClass *) klass;
 143
 144         parent_class = g_type_class_peek_parent (klass);
 145         object_class->finalize = modest_protocol_registry_finalize;
 146         g_type_class_add_private (object_class,
 147                                   sizeof(ModestProtocolRegistryPrivate));
 148 }
 149
 150 static void
 151 modest_protocol_registry_instance_init (ModestProtocolRegistry *obj)
 152 {
 153         ModestProtocolRegistryPrivate *priv;
 154
 155         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (obj);
 156
 157         priv->tags_table = g_hash_table_new_full (g_str_hash, g_str_equal,
 158                                                   g_free, (GDestroyNotify) g_hash_table_unref);
 159         priv->priorities = g_hash_table_new (g_direct_hash, g_direct_equal);
 160
 161         modest_protocol_registry_create_tag (obj, TAG_ALL_PROTOCOLS);
 162 }
 163
 164 static void
 165 modest_protocol_registry_finalize   (GObject *obj)
 166 {
 167         ModestProtocolRegistryPrivate *priv;
 168
 169         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (obj);
 170
 171         /* Free hash tables */
 172         if (priv->tags_table)
 173                 g_hash_table_unref (priv->tags_table);
 174         if (priv->priorities)
 175                 g_hash_table_unref (priv->priorities);
 176
 177         G_OBJECT_CLASS (parent_class)->finalize (obj);
 178 }
 179
 180
 181 ModestProtocolRegistry*
 182 modest_protocol_registry_new ()
 183 {
 184         return g_object_new (MODEST_TYPE_PROTOCOL_REGISTRY, NULL);
 185 }
 186
 187 void
 188 modest_protocol_registry_add (ModestProtocolRegistry *self, ModestProtocol *protocol, gint priority, const gchar *first_tag, ...)
 189 {
 190         va_list list;
 191         GSList *tags_list = NULL, *node = NULL;
 192         const gchar *va_string;
 193         GHashTable *tag_table;
 194         ModestProtocolRegistryPrivate *priv;
 195
 196         g_return_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self));
 197         g_return_if_fail (MODEST_IS_PROTOCOL (protocol));
 198         g_return_if_fail (first_tag != NULL);
 199         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 200
 201         tag_table = g_hash_table_lookup (priv->tags_table, TAG_ALL_PROTOCOLS);
 202         g_hash_table_insert (tag_table, GINT_TO_POINTER (modest_protocol_get_type_id (protocol)), g_object_ref (protocol));
 203
 204         g_hash_table_insert (priv->priorities, GINT_TO_POINTER (modest_protocol_get_type_id (protocol)), GINT_TO_POINTER (priority));
 205
 206         tags_list = g_slist_prepend (tags_list, (gpointer) first_tag);
 207         va_start (list, first_tag);
 208         while ((va_string = va_arg (list, const gchar *)) != NULL) {
 209                 tags_list = g_slist_prepend (tags_list, (gpointer) va_string);
 210         }
 211         va_end (list);
 212
 213         for (node = tags_list; node != NULL; node = g_slist_next (node)) {
 214
 215                 tag_table = g_hash_table_lookup (priv->tags_table, node->data);
 216                 if (tag_table == NULL)
 217                         tag_table = modest_protocol_registry_create_tag (self, node->data);
 218                 g_hash_table_insert (tag_table, GINT_TO_POINTER (modest_protocol_get_type_id (protocol)), g_object_ref (protocol));
 219         }
 220         g_slist_free (tags_list);
 221 }
 222
 223 GSList *
 224 modest_protocol_registry_get_all (ModestProtocolRegistry *self)
 225 {
 226         ModestProtocolRegistryPrivate *priv;
 227
 228         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
 229         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 230
 231         return modest_protocol_registry_get_by_tag (self, TAG_ALL_PROTOCOLS);
 232
 233 }
 234
 235 static void
 236 add_protocol_to_list (ModestProtocolType key, ModestProtocol *protocol, GSList **list)
 237 {
 238         *list = g_slist_prepend (*list, protocol);
 239 }
 240
 241 static gint
 242 compare_protocols (ModestProtocol *a, ModestProtocol *b, GHashTable *priorities)
 243 {
 244         ModestProtocolType a_type, b_type;
 245         gint result;
 246
 247         a_type = modest_protocol_get_type_id (a);
 248         b_type = modest_protocol_get_type_id (b);
 249
 250         result = g_hash_table_lookup (priorities, GINT_TO_POINTER (a_type)) - g_hash_table_lookup (priorities, GINT_TO_POINTER (b_type));
 251         if (result == 0) {
 252                 const gchar *a_display_name;
 253                 const gchar *b_display_name;
 254
 255                 a_display_name = modest_protocol_get_display_name (a);
 256                 b_display_name = modest_protocol_get_display_name (b);
 257                 result = g_utf8_collate (a_display_name, b_display_name);
 258         }
 259         return result;
 260 }
 261
 262 GSList *
 263 modest_protocol_registry_get_by_tag (ModestProtocolRegistry *self, const gchar *tag)
 264 {
 265         ModestProtocolRegistryPrivate *priv;
 266         GHashTable *tag_table;
 267         GSList *result;
 268
 269         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
 270         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 271
 272         tag_table = g_hash_table_lookup (priv->tags_table, tag);
 273         if (tag_table == NULL) {
 274                 return NULL;
 275         }
 276
 277         result = NULL;
 278         g_hash_table_foreach (tag_table, (GHFunc) add_protocol_to_list, &result);
 279
 280         result = g_slist_sort_with_data (result, (GCompareDataFunc) compare_protocols, priv->priorities);
 281
 282         return result;
 283
 284 }
 285
 286 static void
 287 add_protocol_to_pair_list (ModestProtocolType type_id, ModestProtocol *protocol, GSList **list)
 288 {
 289         *list = g_slist_append (*list,
 290                                 (gpointer) modest_pair_new (
 291                                         (gpointer) modest_protocol_get_name (protocol),
 292                                         (gpointer) modest_protocol_get_display_name (protocol),
 293                                         FALSE));
 294 }
 295
 296 ModestPairList *
 297 modest_protocol_registry_get_pair_list_by_tag (ModestProtocolRegistry *self, const gchar *tag)
 298 {
 299         ModestProtocolRegistryPrivate *priv;
 300         GHashTable *tag_table;
 301         GSList *result;
 302
 303         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
 304         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 305
 306         tag_table = g_hash_table_lookup (priv->tags_table, tag);
 307         if (tag_table == NULL) {
 308                 return NULL;
 309         }
 310
 311         g_hash_table_foreach (tag_table, (GHFunc) add_protocol_to_pair_list, &result);
 312
 313         return result;
 314 }
 315
 316 static gboolean
 317 find_protocol_by_name (ModestProtocolType type_id,
 318                        ModestProtocol *protocol,
 319                        const gchar *name)
 320 {
 321         return (strcmp (name, modest_protocol_get_name (protocol)) == 0);
 322 }
 323
 324 ModestProtocol *
 325 modest_protocol_registry_get_protocol_by_name (ModestProtocolRegistry *self, const gchar *tag, const gchar *name)
 326 {
 327         ModestProtocolRegistryPrivate *priv;
 328         GHashTable *tag_table;
 329
 330         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
 331         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 332
 333         tag_table = g_hash_table_lookup (priv->tags_table, tag);
 334         if (tag_table == NULL) {
 335                 return NULL;
 336         }
 337
 338         return g_hash_table_find (tag_table, (GHRFunc) find_protocol_by_name, (gpointer) name);
 339 }
 340
 341 ModestProtocol *
 342 modest_protocol_registry_get_protocol_by_type (ModestProtocolRegistry *self, ModestProtocolType type_id)
 343 {
 344         ModestProtocolRegistryPrivate *priv;
 345         GHashTable *tag_table;
 346
 347         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
 348         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 349
 350         tag_table = g_hash_table_lookup (priv->tags_table, TAG_ALL_PROTOCOLS);
 351         if (tag_table == NULL) {
 352                 return NULL;
 353         }
 354
 355         return g_hash_table_lookup (tag_table, GINT_TO_POINTER (type_id));
 356 }
 357
 358 gboolean
 359 modest_protocol_registry_protocol_type_has_tag (ModestProtocolRegistry *self, ModestProtocolType type_id, const gchar *tag)
 360 {
 361         ModestProtocolRegistryPrivate *priv;
 362         GHashTable *tag_table;
 363
 364         g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), FALSE);
 365         g_return_val_if_fail (tag != NULL, FALSE);
 366         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 367
 368         tag_table = g_hash_table_lookup (priv->tags_table, tag);
 369         if (tag_table == NULL) {
 370                 return FALSE;
 371         }
 372
 373         return (g_hash_table_lookup (tag_table, GINT_TO_POINTER (type_id))!= NULL);
 374
 375 }
 376
 377 static GHashTable *
 378 modest_protocol_registry_create_tag (ModestProtocolRegistry *self, const gchar *tag)
 379 {
 380         ModestProtocolRegistryPrivate *priv;
 381         GHashTable *tag_table;
 382
 383         g_assert (tag != NULL);
 384         priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
 385         tag_table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 386                                            NULL, g_object_unref);
 387         g_hash_table_insert (priv->tags_table, g_strdup (tag), tag_table);
 388
 389         return tag_table;
 390 }
 391
 392 static gchar *
 393 translation_is_userdata (gpointer userdata, ...)
 394 {
 395         va_list args, dest;
 396         gchar *result;
 397
 398         va_start(args, userdata);
 399         va_copy (dest, args);
 400         result = g_strdup_printf (_(userdata), dest);
 401         va_end (args);
 402
 403         return result;
 404 }
 405
 406 static gchar *
 407 translation_is_userdata_no_param (gpointer userdata, ...)
 408 {
 409         gchar *result;
 410
 411         result = g_strdup (_(userdata));
 412
 413         return result;
 414 }
 415
 416
 417 void
 418 modest_protocol_registry_set_to_default (ModestProtocolRegistry *self)
 419 {
 420         ModestProtocol *protocol;
 421         TnyList *account_options;
 422         TnyPair *pair;
 423
 424         protocol = modest_account_protocol_new ("sendmail", N_("Sendmail"),
 425                                                 0, 0,
 426                                                 TNY_TYPE_CAMEL_TRANSPORT_ACCOUNT);
 427         sendmail_protocol_type_id = modest_protocol_get_type_id (protocol);
 428         modest_protocol_registry_add (self, protocol, 1,
 429                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 430                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
 431                                       NULL);
 432         g_object_unref (protocol);
 433
 434         protocol = modest_account_protocol_new ("smtp", N_("SMTP Server"),
 435                                                 25, 465,
 436                                                 TNY_TYPE_CAMEL_TRANSPORT_ACCOUNT);
 437         smtp_protocol_type_id = modest_protocol_get_type_id (protocol);
 438         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ib_ui_smtp_server_invalid", NULL);
 439         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_smtp_authentication_fail_error", NULL);
 440         modest_protocol_registry_add (self, protocol, 2,
 441                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 442                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
 443                                       NULL);
 444         g_object_unref (protocol);
 445
 446         protocol = modest_account_protocol_new ("pop", _("mail_fi_emailtype_pop3"),
 447                                                 110, 995,
 448                                                 TNY_TYPE_CAMEL_POP_STORE_ACCOUNT);
 449         pop_protocol_type_id = modest_protocol_get_type_id (protocol);
 450         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
 451         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
 452         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
 453         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, translation_is_userdata_no_param, "emev_ni_ui_pop3_msg_recv_error", NULL);
 454         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_SSL_PROTO_NAME, translation_is_userdata_no_param, "mcen_fi_advsetup_other_security_securepop3s", NULL);
 455         modest_protocol_registry_add (self, protocol, 3,
 456                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 457                                       MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
 458                                       MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS,
 459                                       MODEST_PROTOCOL_REGISTRY_HAS_LEAVE_ON_SERVER_PROTOCOLS,
 460                                       MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD,
 461                                       NULL);
 462         g_object_unref (protocol);
 463
 464         protocol = modest_account_protocol_new ("imap", _("mail_fi_emailtype_imap"),
 465                                                 143, 993,
 466                                                 TNY_TYPE_CAMEL_IMAP_STORE_ACCOUNT);
 467         imap_protocol_type_id = modest_protocol_get_type_id (protocol);
 468         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX, translation_is_userdata, "emev_nc_delete_mailboximap", NULL);
 469         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
 470         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
 471         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
 472         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, translation_is_userdata, "emev_ni_ui_imap_message_not_available_in_server", NULL);
 473         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_SSL_PROTO_NAME, translation_is_userdata_no_param, "mcen_fi_advsetup_other_security_secureimap4s", NULL);
 474         account_options = tny_simple_list_new ();
 475         pair = tny_pair_new (MODEST_ACCOUNT_OPTION_USE_LSUB, "");
 476         tny_list_append (account_options, G_OBJECT (pair));
 477         g_object_unref (pair);
 478         pair = tny_pair_new (MODEST_ACCOUNT_OPTION_CHECK_ALL, "");
 479         tny_list_append (account_options, G_OBJECT (pair));
 480         g_object_unref (pair);
 481         modest_account_protocol_set_account_options (MODEST_ACCOUNT_PROTOCOL (protocol), account_options);
 482         g_object_unref (account_options);
 483         modest_protocol_registry_add (self, protocol, 4,
 484                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 485                                       MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
 486                                       MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS,
 487                                       MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
 488                                       NULL);
 489         g_object_unref (protocol);
 490
 491         protocol = modest_account_protocol_new ("maildir", N_("Maildir"),
 492                                                 0, 0,
 493                                                 TNY_TYPE_CAMEL_STORE_ACCOUNT);
 494         maildir_protocol_type_id = modest_protocol_get_type_id (protocol);
 495         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
 496                                          translation_is_userdata_no_param, "emev_nc_mailbox_notavailable", NULL);
 497         modest_protocol_registry_add (self, protocol, 5,
 498                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 499                                       MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
 500                                       MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS,
 501                                       MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
 502                                       NULL);
 503         g_object_unref (protocol);
 504
 505         protocol = modest_account_protocol_new ("mbox", N_("MBox"),
 506                                                 0, 0,
 507                                                 TNY_TYPE_CAMEL_STORE_ACCOUNT);
 508         mbox_protocol_type_id = modest_protocol_get_type_id (protocol);
 509         modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
 510                                          translation_is_userdata_no_param, "emev_nc_mailbox_notavailable", NULL);
 511         modest_protocol_registry_add (self, protocol, 6,
 512                                       MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
 513                                       MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
 514                                       MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS,
 515                                       MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
 516                                       NULL);
 517         g_object_unref (protocol);
 518
 519         protocol = modest_protocol_new ("none", N_("None"));
 520         modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_NEVER);
 521         none_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
 522         modest_protocol_registry_add (self, protocol, 7,
 523                                       MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
 524                                       NULL);
 525         g_object_unref (protocol);
 526
 527         protocol = modest_protocol_new ("ssl", N_("SSL"));
 528         modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_WRAPPED);
 529         ssl_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
 530         modest_protocol_registry_add (self, protocol, 8,
 531                                       MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
 532                                       MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
 533                                       MODEST_PROTOCOL_REGISTRY_USE_ALTERNATE_PORT,
 534                                       NULL);
 535         g_object_unref (protocol);
 536
 537         protocol = modest_protocol_new ("tls", N_("TLS"));
 538         modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_TLS);
 539         tls_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
 540         modest_protocol_registry_add (self, protocol, 9,
 541                                       MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
 542                                       MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
 543                                       NULL);
 544         g_object_unref (protocol);
 545
 546         protocol = modest_protocol_new ("tls-op", N_("TLS when possible"));
 547         modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_WHEN_POSSIBLE);
 548         tlsop_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
 549         modest_protocol_registry_add (self, protocol, 10,
 550                                       MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
 551                                       MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
 552                                       NULL);
 553         g_object_unref (protocol);
 554
 555         protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_NONE, _("mcen_fi_advsetup_smtp_none"));
 556         none_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
 557         modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_PLAIN);
 558         modest_protocol_registry_add (self, protocol, 11,
 559                                       MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
 560                                       NULL);
 561         g_object_unref (protocol);
 562
 563         protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_PASSWORD, _("mcen_fi_advsetup_smtp_login"));
 564         password_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
 565         modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_PASSWORD);
 566         modest_protocol_registry_add (self, protocol, 12,
 567                                       MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
 568                                       MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
 569                                       NULL);
 570         g_object_unref (protocol);
 571
 572         protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_CRAMMD5, _("mcen_fi_advsetup_smtp_cram_md5"));
 573         crammd5_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
 574         modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_CRAMMD5);
 575         modest_protocol_registry_add (self, protocol, 13,
 576                                       MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
 577                                       MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
 578                                       NULL);
 579         g_object_unref (protocol);
 580
 581         /* set the custom auth mechs. We do this after creating all the protocols, because if we don't, then we
 582          * won't register the auth protocol type id's properly */
 583
 584         /* IMAP and POP need at least a password,
 585          * which camel uses if we specify NULL.
 586          * Camel use a password for IMAP or POP if we specify NULL,
 587          * For IMAP, at least it will report an error if we use "Password", "Login" or "Plain".
 588          * (POP is know to report an error for Login too. Probably Password and Plain too.) */
 589         protocol = modest_protocol_registry_get_protocol_by_type (self, MODEST_PROTOCOLS_STORE_IMAP);
 590         modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_NONE, NULL);
 591         modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_PASSWORD, NULL);
 592         protocol = modest_protocol_registry_get_protocol_by_type (self, MODEST_PROTOCOLS_STORE_POP);
 593         modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_NONE, NULL);
 594         modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_PASSWORD, NULL);
 595 }
 596
 597 ModestProtocolType
 598 modest_protocol_registry_get_imap_type_id (void)
 599 {
 600         return imap_protocol_type_id;
 601 }
 602
 603 ModestProtocolType
 604 modest_protocol_registry_get_pop_type_id (void)
 605 {
 606         return pop_protocol_type_id;
 607 }
 608
 609 ModestProtocolType
 610 modest_protocol_registry_get_maildir_type_id (void)
 611 {
 612         return maildir_protocol_type_id;
 613 }
 614
 615 ModestProtocolType
 616 modest_protocol_registry_get_mbox_type_id (void)
 617 {
 618         return mbox_protocol_type_id;
 619 }
 620
 621 ModestProtocolType
 622 modest_protocol_registry_get_smtp_type_id (void)
 623 {
 624         return smtp_protocol_type_id;
 625 }
 626
 627 ModestProtocolType
 628 modest_protocol_registry_get_sendmail_type_id (void)
 629 {
 630         return sendmail_protocol_type_id;
 631 }
 632
 633 ModestProtocolType
 634 modest_protocol_registry_get_none_connection_type_id (void)
 635 {
 636         return none_connection_protocol_type_id;
 637 }
 638
 639 ModestProtocolType
 640 modest_protocol_registry_get_ssl_connection_type_id (void)
 641 {
 642         return ssl_connection_protocol_type_id;
 643 }
 644
 645 ModestProtocolType
 646 modest_protocol_registry_get_tls_connection_type_id (void)
 647 {
 648         return tls_connection_protocol_type_id;
 649 }
 650
 651 ModestProtocolType
 652 modest_protocol_registry_get_tlsop_connection_type_id (void)
 653 {
 654         return tlsop_connection_protocol_type_id;
 655 }
 656
 657 ModestProtocolType
 658 modest_protocol_registry_get_none_auth_type_id (void)
 659 {
 660         return none_auth_protocol_type_id;
 661 }
 662
 663 ModestProtocolType
 664 modest_protocol_registry_get_password_auth_type_id (void)
 665 {
 666         return password_auth_protocol_type_id;
 667 }
 668
 669 ModestProtocolType
 670 modest_protocol_registry_get_crammd5_auth_type_id (void)
 671 {
 672         return crammd5_auth_protocol_type_id;
 673 }
 674