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