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

   1 /* Copyright (c) 2006, 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 <glib/gi18n.h>
  31 #include <string.h> /* strcmp */
  32 #include <modest-protocol-info.h>
  33 #include <modest-pair.h>
  34 #include <modest-defs.h>
  35
  36
  37 typedef struct {
  38         gint   proto;
  39         const gchar*     name;
  40         const gchar*     display_name;
  41 } ProtocolInfo;
  42
  43 static const ProtocolInfo TransportStoreProtocolMap[] = {
  44         { MODEST_PROTOCOL_TRANSPORT_SENDMAIL, "sendmail", N_("Sendmail") },
  45         { MODEST_PROTOCOL_TRANSPORT_SMTP,     "smtp",     N_("SMTP Server") },
  46
  47         { MODEST_PROTOCOL_STORE_POP,          "pop",      N_("POP3") },
  48         { MODEST_PROTOCOL_STORE_IMAP,         "imap",     N_("IMAPv4") },
  49         { MODEST_PROTOCOL_STORE_MAILDIR,      "maildir",  N_("Maildir") },
  50         { MODEST_PROTOCOL_STORE_MBOX,         "mbox",     N_("MBox") }
  51 };
  52
  53 static const ProtocolInfo ConnectionProtocolMap[] = {
  54         { MODEST_PROTOCOL_CONNECTION_NORMAL,    "none",     N_("None") },
  55         { MODEST_PROTOCOL_CONNECTION_SSL,       "ssl",      N_("SSL") },
  56         { MODEST_PROTOCOL_CONNECTION_TLS,       "tls",      N_("TLS") },
  57         { MODEST_PROTOCOL_CONNECTION_TLS_OP,    "tls-op",   N_("TLS when possible") }
  58         /* op stands for optional */
  59 };
  60
  61
  62 /* FIXME: these names must match those of tny_camel_account_get_supported_secure_auth */
  63 static const ProtocolInfo AuthProtocolMap[] = {
  64         { MODEST_PROTOCOL_AUTH_NONE,          MODEST_ACCOUNT_AUTH_MECH_VALUE_NONE,     N_("None") },
  65         { MODEST_PROTOCOL_AUTH_PASSWORD,      MODEST_ACCOUNT_AUTH_MECH_VALUE_PASSWORD, N_("Password") },
  66         { MODEST_PROTOCOL_AUTH_CRAMMD5,       MODEST_ACCOUNT_AUTH_MECH_VALUE_CRAMMD5, N_("Cram MD5") }
  67 };
  68
  69
  70 static ModestPairList*
  71 get_protocol_pair_list (const ProtocolInfo* map, guint size)
  72 {
  73         g_return_val_if_fail (map, NULL);
  74
  75         ModestPairList *proto_list = NULL;
  76         int i;
  77         for (i = 0; i != size; ++i) {
  78                 const ProtocolInfo info = map[i];
  79                 proto_list = g_slist_append (proto_list,
  80                                              (gpointer)modest_pair_new(
  81                                                      (gpointer)info.name,
  82                                                      (gpointer)info.display_name,
  83                                                      FALSE));
  84         }
  85         return proto_list;
  86 }
  87
  88
  89 ModestPairList*
  90 modest_protocol_info_get_transport_store_protocol_pair_list ()
  91 {
  92         return get_protocol_pair_list (TransportStoreProtocolMap,
  93                 G_N_ELEMENTS(TransportStoreProtocolMap));
  94 }
  95
  96 ModestPairList*
  97 modest_protocol_info_get_auth_protocol_pair_list ()
  98 {
  99         return get_protocol_pair_list (AuthProtocolMap,
 100                 G_N_ELEMENTS(AuthProtocolMap));
 101 }
 102
 103 ModestPairList*
 104 modest_protocol_info_get_connection_protocol_pair_list ()
 105 {
 106         return get_protocol_pair_list (ConnectionProtocolMap,
 107                 G_N_ELEMENTS(ConnectionProtocolMap));
 108 }
 109
 110
 111 ModestTransportStoreProtocol
 112 modest_protocol_info_get_transport_store_protocol (const gchar* name)
 113 {
 114         const ProtocolInfo *map = TransportStoreProtocolMap;
 115         const guint size = G_N_ELEMENTS(TransportStoreProtocolMap);
 116         int i;
 117
 118         g_return_val_if_fail (name, MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN);
 119
 120         g_return_val_if_fail (map, MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN);
 121
 122         for (i = 0; i != size; ++i) {
 123                 const ProtocolInfo info = map[i];
 124                 if (strcmp(name, info.name) == 0)
 125                         return info.proto;
 126         }
 127
 128         return MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
 129 }
 130
 131
 132
 133 /* get either the name or the display_name for the protocol */
 134 static const gchar*
 135 get_protocol_string (gint proto, const ProtocolInfo* map, guint size, gboolean get_name)
 136 {
 137         g_return_val_if_fail (map, NULL);
 138
 139         int i;
 140         for (i = 0; i != size; ++i) {
 141                 ProtocolInfo info = map[i];
 142                 if (info.proto == proto)
 143                         return get_name ? info.name : info.display_name;
 144         }
 145         g_return_val_if_reached (NULL);
 146 }
 147
 148 const gchar*
 149 modest_protocol_info_get_transport_store_protocol_name (ModestTransportStoreProtocol proto)
 150 {
 151         return get_protocol_string (proto, TransportStoreProtocolMap,
 152                 G_N_ELEMENTS(TransportStoreProtocolMap), TRUE);
 153 }
 154
 155 const gchar*
 156 modest_protocol_info_get_auth_protocol_name (ModestAuthProtocol proto)
 157 {
 158         return get_protocol_string (proto, AuthProtocolMap,
 159                 G_N_ELEMENTS(AuthProtocolMap), TRUE);
 160 }
 161
 162 const gchar*
 163 modest_protocol_info_get_connection_protocol_name (ModestAuthProtocol proto)
 164 {
 165         return get_protocol_string (proto, ConnectionProtocolMap,
 166                 G_N_ELEMENTS(ConnectionProtocolMap), TRUE);
 167 }
 168
 169
 170 gboolean
 171 modest_protocol_info_protocol_is_local_store (ModestTransportStoreProtocol proto)
 172 {
 173         return proto == MODEST_PROTOCOL_STORE_MBOX || proto == MODEST_PROTOCOL_STORE_MAILDIR;
 174 }
 175
 176
 177
 178 gboolean
 179 modest_protocol_info_protocol_is_store (ModestTransportStoreProtocol proto)
 180 {
 181         return proto == MODEST_PROTOCOL_STORE_MBOX || proto == MODEST_PROTOCOL_STORE_MAILDIR ||
 182                 proto == MODEST_PROTOCOL_STORE_POP || proto == MODEST_PROTOCOL_STORE_IMAP;
 183 }
 184
 185 gboolean
 186 modest_protocol_info_is_secure(ModestConnectionProtocol protocol)
 187 {
 188         return (protocol == MODEST_PROTOCOL_CONNECTION_SSL ||
 189                                         protocol == MODEST_PROTOCOL_CONNECTION_TLS);
 190 }
 191
 192 gboolean modest_protocol_info_auth_is_secure(ModestAuthProtocol protocol)
 193 {
 194         return (protocol == MODEST_PROTOCOL_AUTH_CRAMMD5);
 195 }