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