git.maemo.org Git - modest/blob - src/modest-protocol-mgr.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-mgr.h"
  33 #include <modest-pair.h>
  34
  35 /* include other impl specific header files */
  36
  37 /* 'private'/'protected' functions */
  38 static void modest_protocol_mgr_class_init (ModestProtocolMgrClass *klass);
  39 static void modest_protocol_mgr_init       (ModestProtocolMgr *obj);
  40 static void modest_protocol_mgr_finalize   (GObject *obj);
  41 /* list my signals  */
  42 enum {
  43         /* MY_SIGNAL_1, */
  44         /* MY_SIGNAL_2, */
  45         LAST_SIGNAL
  46 };
  47
  48 typedef struct _ModestProtocolMgrPrivate ModestProtocolMgrPrivate;
  49 struct _ModestProtocolMgrPrivate {
  50         GSList *transport_protos;
  51         GSList *store_protos;
  52         GSList *security_protos;
  53         GSList *auth_protos;
  54 };
  55 #define MODEST_PROTOCOL_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  56                                                  MODEST_TYPE_PROTOCOL_MGR, \
  57                                                  ModestProtocolMgrPrivate))
  58 /* globals */
  59 static GObjectClass *parent_class = NULL;
  60
  61 /* uncomment the following if you have defined any signals */
  62 /* static guint signals[LAST_SIGNAL] = {0}; */
  63
  64 GType
  65 modest_protocol_mgr_get_type (void)
  66 {
  67         static GType my_type = 0;
  68         if (!my_type) {
  69                 static const GTypeInfo my_info = {
  70                         sizeof(ModestProtocolMgrClass),
  71                         NULL,           /* base init */
  72                         NULL,           /* base finalize */
  73                         (GClassInitFunc) modest_protocol_mgr_class_init,
  74                         NULL,           /* class finalize */
  75                         NULL,           /* class data */
  76                         sizeof(ModestProtocolMgr),
  77                         1,              /* n_preallocs */
  78                         (GInstanceInitFunc) modest_protocol_mgr_init,
  79                         NULL
  80                 };
  81                 my_type = g_type_register_static (G_TYPE_OBJECT,
  82                                                   "ModestProtocolMgr",
  83                                                   &my_info, 0);
  84         }
  85         return my_type;
  86 }
  87
  88 static void
  89 modest_protocol_mgr_class_init (ModestProtocolMgrClass *klass)
  90 {
  91         GObjectClass *gobject_class;
  92         gobject_class = (GObjectClass*) klass;
  93
  94         parent_class            = g_type_class_peek_parent (klass);
  95         gobject_class->finalize = modest_protocol_mgr_finalize;
  96
  97         g_type_class_add_private (gobject_class, sizeof(ModestProtocolMgrPrivate));
  98
  99         /* signal definitions go here, e.g.: */
 100 /*      signals[MY_SIGNAL_1] = */
 101 /*              g_signal_new ("my_signal_1",....); */
 102 /*      signals[MY_SIGNAL_2] = */
 103 /*              g_signal_new ("my_signal_2",....); */
 104 /*      etc. */
 105 }
 106
 107 static void
 108 modest_protocol_mgr_init (ModestProtocolMgr *obj)
 109 {
 110         ModestProtocolMgrPrivate *priv;
 111         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (obj);
 112
 113         priv->transport_protos = NULL;
 114         priv->store_protos     = NULL;
 115         priv->security_protos  = NULL;
 116         priv->auth_protos      = NULL;
 117 }
 118
 119
 120
 121
 122 static void
 123 modest_protocol_mgr_finalize (GObject *obj)
 124 {
 125         ModestProtocolMgrPrivate *priv;
 126         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (obj);
 127
 128         priv->transport_protos =
 129                 modest_pair_gslist_destroy (priv->transport_protos);
 130         priv->store_protos =
 131                 modest_pair_gslist_destroy (priv->store_protos);
 132         priv->security_protos =
 133                 modest_pair_gslist_destroy (priv->security_protos);
 134         priv->auth_protos =
 135                 modest_pair_gslist_destroy (priv->auth_protos);
 136
 137         G_OBJECT_CLASS(parent_class)->finalize (obj);
 138 }
 139
 140 ModestProtocolMgr*
 141 modest_protocol_mgr_new (void)
 142 {
 143         return MODEST_PROTOCOL_MGR(g_object_new(MODEST_TYPE_PROTOCOL_MGR, NULL));
 144 }
 145
 146
 147
 148 const GSList*
 149 modest_protocol_mgr_get_transport_protocols (ModestProtocolMgr* self)
 150 {
 151         ModestProtocolMgrPrivate *priv;
 152
 153         g_return_val_if_fail (self, NULL);
 154
 155         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (self);
 156
 157         if (!priv->transport_protos) {
 158                 priv->transport_protos =
 159                         g_slist_append (priv->transport_protos,
 160                                         (gpointer)modest_pair_new(
 161                                                 (gpointer)MODEST_PROTOCOL_TRANSPORT_SENDMAIL,
 162                                                 (gpointer)_("Sendmail"), FALSE));
 163                 priv->transport_protos =
 164                         g_slist_append (priv->transport_protos,
 165                                         (gpointer)modest_pair_new(
 166                                                 (gpointer)MODEST_PROTOCOL_TRANSPORT_SMTP,
 167                                                 (gpointer)_("SMTP-server"), FALSE));
 168         }
 169         return priv->transport_protos;
 170 }
 171
 172
 173 const GSList*
 174 modest_protocol_mgr_get_store_protocols (ModestProtocolMgr* self)
 175 {
 176         ModestProtocolMgrPrivate *priv;
 177
 178         g_return_val_if_fail (self, NULL);
 179
 180         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (self);
 181
 182         if (!priv->store_protos) {
 183                 priv->store_protos =
 184                         g_slist_append (priv->store_protos,
 185                                         (gpointer)modest_pair_new(
 186                                                 (gpointer)MODEST_PROTOCOL_STORE_POP,
 187                                                 (gpointer)_("POP3"), FALSE));
 188                 priv->store_protos =
 189                         g_slist_append (priv->store_protos,
 190                                         (gpointer)modest_pair_new(
 191                                                 (gpointer)MODEST_PROTOCOL_STORE_IMAP,
 192                                                 (gpointer)_("IMAP v4"), FALSE));
 193                 priv->store_protos =
 194                         g_slist_append (priv->store_protos,
 195                                         (gpointer)modest_pair_new(
 196                                                 (gpointer)MODEST_PROTOCOL_STORE_MBOX,
 197                                                 (gpointer)_("Mbox"), FALSE));
 198                 priv->store_protos =
 199                         g_slist_append (priv->store_protos,
 200                                         (gpointer)modest_pair_new(
 201                                                 (gpointer)MODEST_PROTOCOL_STORE_MAILDIR,
 202                                                 (gpointer)_("Maildir"), FALSE));
 203         }
 204         return priv->store_protos;
 205 }
 206
 207 const GSList*
 208 modest_protocol_mgr_get_security_protocols (ModestProtocolMgr* self)
 209 {
 210         ModestProtocolMgrPrivate *priv;
 211
 212         g_return_val_if_fail (self, NULL);
 213
 214         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (self);
 215
 216         if (!priv->security_protos) {
 217                 priv->security_protos =
 218                         g_slist_append (priv->security_protos,
 219                                         (gpointer)modest_pair_new(
 220                                                 (gpointer)MODEST_PROTOCOL_SECURITY_NONE,
 221                                                 (gpointer)_("None"), FALSE));
 222                 priv->security_protos =
 223                         g_slist_append (priv->security_protos,
 224                                         (gpointer)modest_pair_new(
 225                                                 (gpointer)MODEST_PROTOCOL_SECURITY_TLS,
 226                                                 (gpointer)_("TLS"), FALSE));
 227                 priv->security_protos =
 228                         g_slist_append (priv->security_protos,
 229                                         (gpointer)modest_pair_new(
 230                                                 (gpointer)MODEST_PROTOCOL_SECURITY_SSL,
 231                                                 (gpointer)_("SSL"), FALSE));
 232         }
 233         return priv->security_protos;
 234 }
 235
 236
 237
 238 const GSList*
 239 modest_protocol_mgr_get_auth_protocols (ModestProtocolMgr* self)
 240 {
 241         ModestProtocolMgrPrivate *priv;
 242
 243         g_return_val_if_fail (self, NULL);
 244
 245         priv = MODEST_PROTOCOL_MGR_GET_PRIVATE (self);
 246
 247         if (!priv->auth_protos) {
 248                 priv->auth_protos =
 249                         g_slist_append (priv->auth_protos,
 250                                         (gpointer)modest_pair_new(
 251                                                 (gpointer)MODEST_PROTOCOL_AUTH_NONE,
 252                                                 (gpointer)_("None"), FALSE));
 253                 priv->auth_protos =
 254                         g_slist_append (priv->auth_protos,
 255                                         (gpointer)modest_pair_new(
 256                                                 (gpointer)MODEST_PROTOCOL_AUTH_PASSWORD,
 257                                                 (gpointer)_("Password"), FALSE));
 258         }
 259         return priv->auth_protos;
 260 }
 261
 262
 263
 264
 265 gboolean
 266 modest_protocol_mgr_protocol_is_valid (ModestProtocolMgr* self, const gchar* proto,
 267                                        ModestProtocolType type)
 268 {
 269         gboolean found = FALSE;
 270
 271         switch (type) {
 272         case MODEST_PROTOCOL_TYPE_ANY:
 273
 274         case MODEST_PROTOCOL_TYPE_TRANSPORT:
 275                 found = found
 276                         || strcmp(proto, MODEST_PROTOCOL_TRANSPORT_SENDMAIL) == 0
 277                         || strcmp(proto, MODEST_PROTOCOL_TRANSPORT_SMTP) == 0;
 278                 if (found || type != MODEST_PROTOCOL_TYPE_ANY)
 279                         break;
 280         case MODEST_PROTOCOL_TYPE_STORE:
 281                 found = found
 282                         || strcmp(proto, MODEST_PROTOCOL_STORE_POP) == 0
 283                         || strcmp(proto, MODEST_PROTOCOL_STORE_IMAP) == 0
 284                         || strcmp(proto, MODEST_PROTOCOL_STORE_MAILDIR) == 0
 285                         || strcmp(proto, MODEST_PROTOCOL_STORE_MBOX) == 0;
 286                 if (found || type != MODEST_PROTOCOL_TYPE_ANY)
 287                         break;
 288
 289         case MODEST_PROTOCOL_TYPE_SECURITY:
 290                 found = found
 291                         || strcmp(proto, MODEST_PROTOCOL_SECURITY_NONE) == 0
 292                         || strcmp(proto, MODEST_PROTOCOL_SECURITY_SSL) == 0
 293                         || strcmp(proto, MODEST_PROTOCOL_SECURITY_TLS) == 0;
 294                 if (found || type != MODEST_PROTOCOL_TYPE_ANY)
 295                         break;
 296
 297         case MODEST_PROTOCOL_TYPE_AUTH:
 298                 found = found
 299                         || strcmp(proto, MODEST_PROTOCOL_AUTH_NONE) == 0
 300                         || strcmp(proto, MODEST_PROTOCOL_AUTH_PASSWORD) == 0;
 301                 break;
 302         default:
 303                 g_warning ("invalid protocol type %d", type);
 304         }
 305
 306         return found;
 307 }