git.maemo.org Git - modest/blob - src/maemo/easysetup/modest-presets.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 <string.h> /* for strcmp */
  31 #include "modest-presets.h"
  32 #include <stdio.h>
  33
  34 /* Include config.h so that _() works: */
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 #define MODEST_PRESETS_KEY_NAME                "Name"
  40 #define MODEST_PRESETS_KEY_DOMAIN              "Domain"
  41 #define MODEST_PRESETS_KEY_MCC                 "MCC"
  42 #define MODEST_PRESETS_KEY_INCOMING            "IncomingMailServer"
  43 #define MODEST_PRESETS_KEY_INCOMING_SECURITY   "IncomingSecurity"
  44 #define MODEST_PRESETS_KEY_OUTGOING            "OutgoingMailServer"
  45 #define MODEST_PRESETS_KEY_MAILBOX_TYPE        "MailboxType"
  46 #define MODEST_PRESETS_KEY_APOP                "APOPSecureLogin"
  47 #define MODEST_PRESETS_KEY_SECURE_SMTP         "SecureSmtp"
  48 #define MODEST_PRESETS_KEY_SMTP_PORT           "SmtpPort"
  49
  50
  51 ModestPresets*
  52 modest_presets_new (const gchar *presetfile)
  53 {
  54         ModestPresets *presets = NULL;
  55         GError        *err     = NULL;
  56
  57         g_return_val_if_fail (presetfile, NULL);
  58
  59         presets = g_new (ModestPresets, 1);
  60         presets->keyfile = g_key_file_new ();
  61
  62         if (!presets->keyfile) {
  63                 g_printerr ("modest: cannot instantiate GKeyFile\n");
  64                 g_free (presets);
  65                 return NULL;
  66         }
  67
  68         if (!g_key_file_load_from_file (presets->keyfile, presetfile,
  69                                         G_KEY_FILE_NONE, &err)) {
  70                 g_printerr ("modest: cannot open keyfile from %s:\n  %s\n", presetfile,
  71                             err ? err->message : "unknown reason");
  72                 g_error_free (err);
  73                 g_free (presets);
  74                 return NULL;
  75         }
  76
  77         return presets;
  78 }
  79
  80 gchar**
  81 modest_presets_get_providers  (ModestPresets *self, guint mcc,
  82                                gboolean include_globals, gchar ***provider_ids)
  83 {
  84         gchar **all_providers = NULL;
  85         gchar **all_provider_ids = NULL;
  86         gchar **filtered  = NULL;
  87         gchar **filtered_ids = NULL;
  88         GError *err       = NULL;
  89         guint i, j, len;
  90
  91         g_return_val_if_fail (self && self->keyfile, NULL);
  92
  93         /* Get all the provider IDs: */
  94         all_provider_ids = g_key_file_get_groups (self->keyfile, NULL);
  95         len = g_strv_length(all_provider_ids);
  96
  97         /* Get the names for all these providers: */
  98         all_providers = g_new0(gchar*, len + 1); /* Provider names. */
  99         for (i=0; i != len; ++i) {
 100                 const gchar * provider_id = all_provider_ids[i];
 101                 if(provider_id) {
 102                         gchar* name = g_key_file_get_string(self->keyfile, provider_id,
 103                                 MODEST_PRESETS_KEY_NAME, NULL);
 104
 105                         /* Be forgiving of missing names.
 106                          * If we use NULL then we will null-terminate the array.
 107                          */
 108                         if(!name)
 109                                 name = g_strdup("");
 110
 111                         all_providers[i] = name;
 112                 }
 113                 else
 114                         all_providers[i] = NULL;
 115         };
 116
 117         /* return *all* providers? */
 118         /*
 119         if (mcc == 0 && include_globals) {
 120                 *provider_ids = all_provider_ids;
 121                 return all_providers;
 122         }
 123         */
 124
 125         /* nope: filter them */
 126
 127         filtered = g_new0(gchar*, len + 1); /* Provider names. */
 128         filtered_ids = g_new0(gchar*, len + 1); /* Provider IDs */
 129
 130         for (i=0, j=0; i != len; ++i) {
 131
 132                 int this_mcc;
 133                 this_mcc = g_key_file_get_integer (self->keyfile, all_provider_ids[i],
 134                                                    MODEST_PRESETS_KEY_MCC, &err);
 135                 if (err) {
 136                         g_strfreev (all_providers);
 137                         g_strfreev (all_provider_ids);
 138                         g_strfreev (filtered);
 139                         g_strfreev (filtered_ids);
 140
 141                         g_printerr ("modest: error parsing keyfile: %s\n", err->message);
 142                         g_error_free (err);
 143
 144                         return NULL;
 145                 }
 146
 147                 if (this_mcc == mcc || (this_mcc == 0 && include_globals)) {
 148                         filtered[j]   = all_providers[i];
 149                         filtered_ids[j]   = all_provider_ids[i];
 150                         ++j;
 151                         filtered[j] = NULL; /* the array must be NULL-terminated */
 152                         filtered_ids[j] = NULL; /* the array must be NULL-terminated */
 153
 154                         all_providers[i]  = NULL; /*  g_strfreev: leave it alone */
 155                         all_provider_ids[i]  = NULL; /*  g_strfreev: leave it alone */
 156                 }
 157         }
 158
 159         g_strfreev (all_providers);
 160         g_strfreev (all_provider_ids);
 161
 162         *provider_ids = filtered_ids;
 163         return filtered;
 164 }
 165
 166
 167 gchar*
 168 modest_presets_get_server (ModestPresets *self, const gchar *provider_id,
 169                            gboolean incoming_server)
 170 {
 171         g_return_val_if_fail (self && self->keyfile, NULL);
 172         g_return_val_if_fail (provider_id, NULL);
 173
 174         return g_key_file_get_string (self->keyfile, provider_id,
 175                                       incoming_server ?
 176                                       MODEST_PRESETS_KEY_INCOMING :
 177                                       MODEST_PRESETS_KEY_OUTGOING,
 178                                       NULL);
 179 }
 180
 181 gchar *
 182 modest_presets_get_domain      (ModestPresets *self,
 183                                 const gchar *provider_id)
 184 {
 185         g_return_val_if_fail (self && self->keyfile, NULL);
 186         g_return_val_if_fail (provider_id, NULL);
 187
 188         return g_key_file_get_string (self->keyfile, provider_id,
 189                                       MODEST_PRESETS_KEY_DOMAIN,
 190                                       NULL);
 191 }
 192
 193
 194
 195
 196 ModestPresetsServerType
 197 modest_presets_get_info_server_type (ModestPresets *self,
 198                                      const gchar *provider_id,
 199                                      gboolean incoming_server)
 200 {
 201         ModestPresetsServerType info = MODEST_PRESETS_SERVER_TYPE_NONE;
 202         gchar *val = NULL;
 203
 204         g_return_val_if_fail (self && self->keyfile, 0);
 205
 206         if (incoming_server) {
 207                 val = g_key_file_get_string (self->keyfile, provider_id,
 208                                              MODEST_PRESETS_KEY_INCOMING, NULL);
 209                 if (!val)
 210                         return info;
 211
 212                 g_free (val);
 213                 val = g_key_file_get_string (self->keyfile, provider_id,
 214                                              MODEST_PRESETS_KEY_MAILBOX_TYPE,NULL);
 215                 if (val && strcmp (val, "pop") == 0)
 216                         info = MODEST_PRESETS_SERVER_TYPE_POP;
 217                 if (val && strcmp (val, "imap") == 0)
 218                         info = MODEST_PRESETS_SERVER_TYPE_IMAP;
 219         } else {
 220                 val = g_key_file_get_string (self->keyfile, provider_id,
 221                                              MODEST_PRESETS_KEY_OUTGOING, NULL);
 222                 if (!val)
 223                         return info;
 224                 info = MODEST_PRESETS_SERVER_TYPE_SMTP;
 225         }
 226         g_free (val);
 227
 228         /* debug: */
 229 /*      g_message ("provider id: %s, server type: %d", provider_id, info); */
 230         return info;
 231 }
 232
 233
 234
 235 ModestPresetsSecurity
 236 modest_presets_get_info_server_security (ModestPresets *self, const gchar *provider_id,
 237                                          gboolean incoming_server)
 238 {
 239         ModestPresetsSecurity info = MODEST_PRESETS_SECURITY_NONE;
 240         gchar *val = NULL;
 241
 242         g_return_val_if_fail (self && self->keyfile, MODEST_PRESETS_SECURITY_NONE);
 243
 244         if (incoming_server) {
 245                 val = g_key_file_get_string (self->keyfile, provider_id,
 246                                              MODEST_PRESETS_KEY_INCOMING, NULL);
 247                 if (val) {
 248                         g_free (val);
 249                         val = g_key_file_get_string (self->keyfile, provider_id,
 250                                                      MODEST_PRESETS_KEY_APOP, NULL);
 251                         if (val && strcmp(val, "true") == 0)
 252                                 info |= MODEST_PRESETS_SECURITY_APOP;
 253                         g_free(val);
 254
 255                         val = g_key_file_get_string (self->keyfile, provider_id,
 256                                                      MODEST_PRESETS_KEY_INCOMING_SECURITY, NULL);
 257                         if (val && strcmp (val, "1") == 0)
 258                                 info |= MODEST_PRESETS_SECURITY_SECURE_INCOMING;
 259                         if (val && strcmp (val, "2") == 0) {
 260                                 info |= MODEST_PRESETS_SECURITY_SECURE_INCOMING;
 261                                 info |= MODEST_PRESETS_SECURITY_SECURE_INCOMING_ALTERNATE_PORT;
 262                         }
 263                         g_free (val);
 264                 }
 265         } else /* outgoing: */ {
 266                 val = g_key_file_get_string (self->keyfile, provider_id,
 267                                              MODEST_PRESETS_KEY_OUTGOING, NULL);
 268                 if (val) {
 269                         g_free (val);
 270
 271                         val = g_key_file_get_string (self->keyfile, provider_id,
 272                                                      MODEST_PRESETS_KEY_SECURE_SMTP, NULL);
 273                         /* printf("debug: %s: provider_id=%s, secure-smtp val=%s\n", __FUNCTION__, provider_id, val); */
 274                         if (val && strcmp(val,"true") == 0)
 275                                 info |= MODEST_PRESETS_SECURITY_SECURE_SMTP;
 276                         g_free(val);
 277                 }
 278         }
 279
 280         return info;
 281 }
 282
 283
 284 /*
 285  * at the moment, this only for mac.com, which have a special SMTP port
 286  */
 287 guint
 288 modest_presets_get_port (ModestPresets *self, const gchar* provider_id,
 289                          gboolean incoming_server)
 290 {
 291         guint port;
 292
 293         g_return_val_if_fail (self && self->keyfile, 0);
 294
 295         if (incoming_server)
 296                 port = 0; /* not used yet */
 297         else
 298                 port = (guint)g_key_file_get_integer (self->keyfile, provider_id,
 299                                                       MODEST_PRESETS_KEY_SMTP_PORT, NULL);
 300
 301         return port;
 302 }
 303
 304
 305
 306
 307
 308 void
 309 modest_presets_destroy (ModestPresets *self)
 310 {
 311         if (!self)
 312                 return;
 313
 314         g_key_file_free (self->keyfile);
 315         self->keyfile = NULL;
 316
 317         g_free (self);
 318 }