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

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