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 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 static gint
  88 get_protocol_by_name (const ProtocolInfo* map,
  89                       guint size,
  90                       const gchar* query_name,
  91                       gint default_value,
  92                       gboolean case_sensitive)
  93 {
  94         guint i;
  95
  96         g_return_val_if_fail (map, default_value);
  97
  98         for(i = 0; i < size; ++i)
  99         {
 100                 if((case_sensitive && strcmp(map[i].name, query_name) == 0) ||
 101                    (!case_sensitive && g_ascii_strcasecmp(map[i].name, query_name) == 0))
 102                 {
 103                         return map[i].proto;
 104                 }
 105         }
 106
 107         return default_value;
 108 }
 109
 110 ModestPairList*
 111 modest_protocol_info_get_transport_store_protocol_pair_list ()
 112 {
 113         return get_protocol_pair_list (TransportStoreProtocolMap,
 114                 G_N_ELEMENTS(TransportStoreProtocolMap));
 115 }
 116
 117 ModestPairList*
 118 modest_protocol_info_get_auth_protocol_pair_list ()
 119 {
 120         return get_protocol_pair_list (AuthProtocolMap,
 121                 G_N_ELEMENTS(AuthProtocolMap));
 122 }
 123
 124 ModestPairList*
 125 modest_protocol_info_get_connection_protocol_pair_list ()
 126 {
 127         return get_protocol_pair_list (ConnectionProtocolMap,
 128                 G_N_ELEMENTS(ConnectionProtocolMap));
 129 }
 130
 131 ModestTransportStoreProtocol
 132 modest_protocol_info_get_transport_store_protocol (const gchar* name)
 133 {
 134         return get_protocol_by_name(TransportStoreProtocolMap,
 135                                     G_N_ELEMENTS(TransportStoreProtocolMap),
 136                                     name,
 137                                     MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN,
 138                                     TRUE);
 139 }
 140
 141 ModestAuthProtocol
 142 modest_protocol_info_get_auth_protocol (const gchar* name)
 143 {
 144         return get_protocol_by_name(AuthProtocolMap,
 145                                     G_N_ELEMENTS(AuthProtocolMap),
 146                                     name,
 147                                     MODEST_PROTOCOL_AUTH_NONE,
 148                                     FALSE);
 149 }
 150
 151
 152 /* get either the name or the display_name for the protocol */
 153 static const gchar*
 154 get_protocol_string (gint proto, const ProtocolInfo* map, guint size, gboolean get_name)
 155 {
 156         g_return_val_if_fail (map, NULL);
 157
 158         int i;
 159         for (i = 0; i != size; ++i) {
 160                 ProtocolInfo info = map[i];
 161                 if (info.proto == proto)
 162                         return get_name ? info.name : info.display_name;
 163         }
 164         g_return_val_if_reached (NULL);
 165 }
 166
 167 const gchar*
 168 modest_protocol_info_get_transport_store_protocol_name (ModestTransportStoreProtocol proto)
 169 {
 170         return get_protocol_string (proto, TransportStoreProtocolMap,
 171                 G_N_ELEMENTS(TransportStoreProtocolMap), TRUE);
 172 }
 173
 174 const gchar*
 175 modest_protocol_info_get_auth_protocol_name (ModestAuthProtocol proto)
 176 {
 177         return get_protocol_string (proto, AuthProtocolMap,
 178                 G_N_ELEMENTS(AuthProtocolMap), TRUE);
 179 }
 180
 181 const gchar*
 182 modest_protocol_info_get_connection_protocol_name (ModestAuthProtocol proto)
 183 {
 184         return get_protocol_string (proto, ConnectionProtocolMap,
 185                 G_N_ELEMENTS(ConnectionProtocolMap), TRUE);
 186 }
 187
 188
 189 gboolean
 190 modest_protocol_info_protocol_is_local_store (ModestTransportStoreProtocol proto)
 191 {
 192         return proto == MODEST_PROTOCOL_STORE_MBOX || proto == MODEST_PROTOCOL_STORE_MAILDIR;
 193 }
 194
 195
 196
 197 gboolean
 198 modest_protocol_info_protocol_is_store (ModestTransportStoreProtocol proto)
 199 {
 200         return proto == MODEST_PROTOCOL_STORE_MBOX || proto == MODEST_PROTOCOL_STORE_MAILDIR ||
 201                 proto == MODEST_PROTOCOL_STORE_POP || proto == MODEST_PROTOCOL_STORE_IMAP;
 202 }
 203
 204 gboolean
 205 modest_protocol_info_is_secure(ModestConnectionProtocol protocol)
 206 {
 207         return (protocol == MODEST_PROTOCOL_CONNECTION_SSL ||
 208                                         protocol == MODEST_PROTOCOL_CONNECTION_TLS);
 209 }
 210
 211 gboolean modest_protocol_info_auth_is_secure(ModestAuthProtocol protocol)
 212 {
 213         return (protocol == MODEST_PROTOCOL_AUTH_CRAMMD5);
 214 }