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