1 /* Copyright (c) 2007, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
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.
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.
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>
40 #define TAG_ALL_PROTOCOLS "__MODEST_PROTOCOL_REGISTRY_ALL_PROTOCOLS"
42 /* These seem to be listed in
43 * libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c
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"
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.
61 /* Note that evolution does not offer these for IMAP: */
62 #define MODEST_ACCOUNT_AUTH_PLAIN "PLAIN"
63 #define MODEST_ACCOUNT_AUTH_ANONYMOUS "ANONYMOUS"
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"
70 /* These seem to be listed in
71 * libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-provider.c
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 */
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);
82 /* translation handlers */
83 static gchar * translation_is_userdata (gpointer userdata, ...);
85 typedef struct _ModestProtocolRegistryPrivate ModestProtocolRegistryPrivate;
86 struct _ModestProtocolRegistryPrivate {
87 GHashTable *tags_table;
88 GHashTable *priorities;
91 #define MODEST_PROTOCOL_REGISTRY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
92 MODEST_TYPE_PROTOCOL_REGISTRY, \
93 ModestProtocolRegistryPrivate))
96 static GObjectClass *parent_class = NULL;
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;
113 modest_protocol_registry_get_type (void)
115 static GType my_type = 0;
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),
127 (GInstanceInitFunc) modest_protocol_registry_instance_init,
131 my_type = g_type_register_static (G_TYPE_OBJECT,
132 "ModestProtocolRegistry",
139 modest_protocol_registry_class_init (ModestProtocolRegistryClass *klass)
141 GObjectClass *object_class;
142 object_class = (GObjectClass *) klass;
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));
151 modest_protocol_registry_instance_init (ModestProtocolRegistry *obj)
153 ModestProtocolRegistryPrivate *priv;
155 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (obj);
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);
161 modest_protocol_registry_create_tag (obj, TAG_ALL_PROTOCOLS);
165 modest_protocol_registry_finalize (GObject *obj)
167 ModestProtocolRegistryPrivate *priv;
169 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (obj);
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);
177 G_OBJECT_CLASS (parent_class)->finalize (obj);
181 ModestProtocolRegistry*
182 modest_protocol_registry_new ()
184 return g_object_new (MODEST_TYPE_PROTOCOL_REGISTRY, NULL);
188 modest_protocol_registry_add (ModestProtocolRegistry *self, ModestProtocol *protocol, gint priority, const gchar *first_tag, ...)
191 GSList *tags_list = NULL, *node = NULL;
192 const gchar *va_string;
193 GHashTable *tag_table;
194 ModestProtocolRegistryPrivate *priv;
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);
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));
204 g_hash_table_insert (priv->priorities, GINT_TO_POINTER (modest_protocol_get_type_id (protocol)), GINT_TO_POINTER (priority));
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);
213 for (node = tags_list; node != NULL; node = g_slist_next (node)) {
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));
220 g_slist_free (tags_list);
224 modest_protocol_registry_get_all (ModestProtocolRegistry *self)
226 ModestProtocolRegistryPrivate *priv;
228 g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
229 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
231 return modest_protocol_registry_get_by_tag (self, TAG_ALL_PROTOCOLS);
236 add_protocol_to_list (ModestProtocolType key, ModestProtocol *protocol, GSList **list)
238 *list = g_slist_prepend (*list, protocol);
242 compare_protocols (ModestProtocol *a, ModestProtocol *b, GHashTable *priorities)
244 ModestProtocolType a_type, b_type;
247 a_type = modest_protocol_get_type_id (a);
248 b_type = modest_protocol_get_type_id (b);
250 result = g_hash_table_lookup (priorities, GINT_TO_POINTER (a_type)) - g_hash_table_lookup (priorities, GINT_TO_POINTER (b_type));
252 const gchar *a_display_name;
253 const gchar *b_display_name;
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);
263 modest_protocol_registry_get_by_tag (ModestProtocolRegistry *self, const gchar *tag)
265 ModestProtocolRegistryPrivate *priv;
266 GHashTable *tag_table;
269 g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
270 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
272 tag_table = g_hash_table_lookup (priv->tags_table, tag);
273 if (tag_table == NULL) {
278 g_hash_table_foreach (tag_table, (GHFunc) add_protocol_to_list, &result);
280 result = g_slist_sort_with_data (result, (GCompareDataFunc) compare_protocols, priv->priorities);
287 add_protocol_to_pair_list (ModestProtocolType type_id, ModestProtocol *protocol, GSList **list)
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),
297 modest_protocol_registry_get_pair_list_by_tag (ModestProtocolRegistry *self, const gchar *tag)
299 ModestProtocolRegistryPrivate *priv;
300 GHashTable *tag_table;
303 g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
304 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
306 tag_table = g_hash_table_lookup (priv->tags_table, tag);
307 if (tag_table == NULL) {
311 g_hash_table_foreach (tag_table, (GHFunc) add_protocol_to_pair_list, &result);
317 find_protocol_by_name (ModestProtocolType type_id,
318 ModestProtocol *protocol,
321 return (strcmp (name, modest_protocol_get_name (protocol)) == 0);
325 modest_protocol_registry_get_protocol_by_name (ModestProtocolRegistry *self, const gchar *tag, const gchar *name)
327 ModestProtocolRegistryPrivate *priv;
328 GHashTable *tag_table;
330 g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
331 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
333 tag_table = g_hash_table_lookup (priv->tags_table, tag);
334 if (tag_table == NULL) {
338 return g_hash_table_find (tag_table, (GHRFunc) find_protocol_by_name, (gpointer) name);
342 modest_protocol_registry_get_protocol_by_type (ModestProtocolRegistry *self, ModestProtocolType type_id)
344 ModestProtocolRegistryPrivate *priv;
345 GHashTable *tag_table;
347 g_return_val_if_fail (MODEST_IS_PROTOCOL_REGISTRY (self), NULL);
348 priv = MODEST_PROTOCOL_REGISTRY_GET_PRIVATE (self);
350 tag_table = g_hash_table_lookup (priv->tags_table, TAG_ALL_PROTOCOLS);
351 if (tag_table == NULL) {
355 return g_hash_table_lookup (tag_table, GINT_TO_POINTER (type_id));
359 modest_protocol_registry_protocol_type_has_tag (ModestProtocolRegistry *self, ModestProtocolType type_id, const gchar *tag)
361 ModestProtocolRegistryPrivate *priv;
362 GHashTable *tag_table;
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);
368 tag_table = g_hash_table_lookup (priv->tags_table, tag);
369 if (tag_table == NULL) {
373 return (g_hash_table_lookup (tag_table, GINT_TO_POINTER (type_id))!= NULL);
378 modest_protocol_registry_create_tag (ModestProtocolRegistry *self, const gchar *tag)
380 ModestProtocolRegistryPrivate *priv;
381 GHashTable *tag_table;
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);
393 translation_is_userdata (gpointer userdata, ...)
398 va_start(args, userdata);
399 va_copy (dest, args);
400 result = g_strdup_printf (_(userdata), dest);
407 translation_is_userdata_no_param (gpointer userdata, ...)
411 result = g_strdup (_(userdata));
418 modest_protocol_registry_set_to_default (ModestProtocolRegistry *self)
420 ModestProtocol *protocol;
421 TnyList *account_options;
424 protocol = modest_account_protocol_new ("sendmail", N_("Sendmail"),
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,
433 protocol = modest_account_protocol_new ("smtp", N_("SMTP Server"),
435 TNY_TYPE_CAMEL_TRANSPORT_ACCOUNT);
436 smtp_protocol_type_id = modest_protocol_get_type_id (protocol);
437 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ib_ui_smtp_server_invalid", NULL);
438 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_smtp_authentication_fail_error", NULL);
439 modest_protocol_registry_add (self, protocol, 2,
440 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
441 MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
444 protocol = modest_account_protocol_new ("pop", _("mail_fi_emailtype_pop3"),
446 TNY_TYPE_CAMEL_POP_STORE_ACCOUNT);
447 pop_protocol_type_id = modest_protocol_get_type_id (protocol);
448 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
449 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
450 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, translation_is_userdata, "emev_ni_ui_pop3_msg_connect_error", NULL);
451 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, translation_is_userdata_no_param, "emev_ni_ui_pop3_msg_recv_error", NULL);
452 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_SSL_PROTO_NAME, translation_is_userdata_no_param, "mcen_fi_advsetup_other_security_securepop3s", NULL);
453 modest_protocol_registry_add (self, protocol, 3,
454 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
455 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
456 MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS,
457 MODEST_PROTOCOL_REGISTRY_HAS_LEAVE_ON_SERVER_PROTOCOLS,
458 MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD,
461 protocol = modest_account_protocol_new ("imap", _("mail_fi_emailtype_imap"),
463 TNY_TYPE_CAMEL_IMAP_STORE_ACCOUNT);
464 imap_protocol_type_id = modest_protocol_get_type_id (protocol);
465 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX, translation_is_userdata, "emev_nc_delete_mailboximap", NULL);
466 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
467 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
468 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, translation_is_userdata, "emev_ni_ui_imap_connect_server_error", NULL);
469 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, translation_is_userdata, "emev_ni_ui_imap_message_not_available_in_server", NULL);
470 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_SSL_PROTO_NAME, translation_is_userdata_no_param, "mcen_fi_advsetup_other_security_secureimap4s", NULL);
471 account_options = tny_simple_list_new ();
472 pair = tny_pair_new (MODEST_ACCOUNT_OPTION_USE_LSUB, "");
473 tny_list_append (account_options, G_OBJECT (pair));
474 g_object_unref (pair);
475 pair = tny_pair_new (MODEST_ACCOUNT_OPTION_CHECK_ALL, "");
476 tny_list_append (account_options, G_OBJECT (pair));
477 g_object_unref (pair);
478 modest_account_protocol_set_account_options (MODEST_ACCOUNT_PROTOCOL (protocol), account_options);
479 g_object_unref (account_options);
480 modest_protocol_registry_add (self, protocol, 4,
481 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
482 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
483 MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS,
484 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
487 protocol = modest_account_protocol_new ("maildir", N_("Maildir"),
489 TNY_TYPE_CAMEL_STORE_ACCOUNT);
490 maildir_protocol_type_id = modest_protocol_get_type_id (protocol);
491 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
492 translation_is_userdata_no_param, "emev_nc_mailbox_notavailable", NULL);
493 modest_protocol_registry_add (self, protocol, 5,
494 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
495 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
496 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS,
497 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
500 protocol = modest_account_protocol_new ("mbox", N_("MBox"),
502 TNY_TYPE_CAMEL_STORE_ACCOUNT);
503 mbox_protocol_type_id = modest_protocol_get_type_id (protocol);
504 modest_protocol_set_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
505 translation_is_userdata_no_param, "emev_nc_mailbox_notavailable", NULL);
506 modest_protocol_registry_add (self, protocol, 6,
507 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
508 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
509 MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS,
510 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
513 protocol = modest_protocol_new ("none", N_("None"));
514 modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_NEVER);
515 none_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
516 modest_protocol_registry_add (self, protocol, 7,
517 MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
519 protocol = modest_protocol_new ("ssl", N_("SSL"));
520 modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_WRAPPED);
521 ssl_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
522 modest_protocol_registry_add (self, protocol, 8,
523 MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
524 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
525 MODEST_PROTOCOL_REGISTRY_USE_ALTERNATE_PORT,
527 protocol = modest_protocol_new ("tls", N_("TLS"));
528 modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_TLS);
529 tls_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
530 modest_protocol_registry_add (self, protocol, 9,
531 MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
532 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
534 protocol = modest_protocol_new ("tls-op", N_("TLS when possible"));
535 modest_protocol_set (protocol, MODEST_PROTOCOL_SECURITY_ACCOUNT_OPTION, MODEST_ACCOUNT_OPTION_SSL_WHEN_POSSIBLE);
536 tlsop_connection_protocol_type_id = modest_protocol_get_type_id (protocol);
537 modest_protocol_registry_add (self, protocol, 10,
538 MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
539 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
541 protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_NONE, _("mcen_fi_advsetup_smtp_none"));
542 none_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
543 modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_PLAIN);
544 modest_protocol_registry_add (self, protocol, 11,
545 MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
547 protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_PASSWORD, _("mcen_fi_advsetup_smtp_login"));
548 password_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
549 modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_PASSWORD);
550 modest_protocol_registry_add (self, protocol, 12,
551 MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
552 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
554 protocol = modest_protocol_new (MODEST_ACCOUNT_AUTH_MECH_VALUE_CRAMMD5, _("mcen_fi_advsetup_smtp_cram_md5"));
555 crammd5_auth_protocol_type_id = modest_protocol_get_type_id (protocol);
556 modest_protocol_set (protocol, MODEST_PROTOCOL_AUTH_ACCOUNT_OPTION, MODEST_ACCOUNT_AUTH_CRAMMD5);
557 modest_protocol_registry_add (self, protocol, 13,
558 MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
559 MODEST_PROTOCOL_REGISTRY_SECURE_PROTOCOLS,
563 /********** WARNING: Test code ( *********/
564 #include "modest-testplugin-protocol.h"
565 protocol = (ModestProtocol *)
566 modest_testplugin_protocol_new ("testplugin", _("mcen_va_testplugin"),
568 TNY_TYPE_CAMEL_IMAP_STORE_ACCOUNT);
569 modest_protocol_registry_add (self, protocol, 50,
570 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
571 MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS,
572 MODEST_PROTOCOL_REGISTRY_REMOTE_STORE_PROTOCOLS,
573 MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS,
574 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS,
577 protocol = (ModestProtocol *)
578 modest_testplugin_protocol_new ("testplugin-transport", _("mcen_va_testplugin"),
580 TNY_TYPE_CAMEL_TRANSPORT_ACCOUNT);
581 modest_protocol_registry_add (self, protocol, 51,
582 MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
583 MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
584 MODEST_PROTOCOL_REGISTRY_PROVIDER_PROTOCOLS,
587 /********* WARNING: Test code ( *********/
591 /* set the custom auth mechs. We do this after creating all the protocols, because if we don't, then we
592 * won't register the auth protocol type id's properly */
594 /* IMAP and POP need at least a password,
595 * which camel uses if we specify NULL.
596 * Camel use a password for IMAP or POP if we specify NULL,
597 * For IMAP, at least it will report an error if we use "Password", "Login" or "Plain".
598 * (POP is know to report an error for Login too. Probably Password and Plain too.) */
599 protocol = modest_protocol_registry_get_protocol_by_type (self, MODEST_PROTOCOLS_STORE_IMAP);
600 modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_NONE, NULL);
601 modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_PASSWORD, NULL);
602 protocol = modest_protocol_registry_get_protocol_by_type (self, MODEST_PROTOCOLS_STORE_POP);
603 modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_NONE, NULL);
604 modest_account_protocol_set_custom_secure_auth_mech (MODEST_ACCOUNT_PROTOCOL (protocol), MODEST_PROTOCOLS_AUTH_PASSWORD, NULL);
608 modest_protocol_registry_get_imap_type_id (void)
610 return imap_protocol_type_id;
614 modest_protocol_registry_get_pop_type_id (void)
616 return pop_protocol_type_id;
620 modest_protocol_registry_get_maildir_type_id (void)
622 return maildir_protocol_type_id;
626 modest_protocol_registry_get_mbox_type_id (void)
628 return mbox_protocol_type_id;
632 modest_protocol_registry_get_smtp_type_id (void)
634 return smtp_protocol_type_id;
638 modest_protocol_registry_get_sendmail_type_id (void)
640 return sendmail_protocol_type_id;
644 modest_protocol_registry_get_none_connection_type_id (void)
646 return none_connection_protocol_type_id;
650 modest_protocol_registry_get_ssl_connection_type_id (void)
652 return ssl_connection_protocol_type_id;
656 modest_protocol_registry_get_tls_connection_type_id (void)
658 return tls_connection_protocol_type_id;
662 modest_protocol_registry_get_tlsop_connection_type_id (void)
664 return tlsop_connection_protocol_type_id;
668 modest_protocol_registry_get_none_auth_type_id (void)
670 return none_auth_protocol_type_id;
674 modest_protocol_registry_get_password_auth_type_id (void)
676 return password_auth_protocol_type_id;
680 modest_protocol_registry_get_crammd5_auth_type_id (void)
682 return crammd5_auth_protocol_type_id;