git.maemo.org Git - modest/blob - src/modest-server-account-settings.c

   1 /* Copyright (c) 2007, 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 <modest-server-account-settings.h>
  31
  32 /* 'private'/'protected' functions */
  33 static void   modest_server_account_settings_class_init (ModestServerAccountSettingsClass *klass);
  34 static void   modest_server_account_settings_finalize   (GObject *obj);
  35 static void   modest_server_account_settings_instance_init (ModestServerAccountSettings *obj);
  36
  37 typedef struct _ModestServerAccountSettingsPrivate ModestServerAccountSettingsPrivate;
  38 struct _ModestServerAccountSettingsPrivate {
  39         gchar *hostname;
  40         guint port;
  41         ModestTransportStoreProtocol protocol;
  42         gchar *username;
  43         gchar *password;
  44         ModestConnectionProtocol security;
  45         ModestAuthProtocol auth_protocol;
  46         gchar *account_name;
  47         gchar *uri;
  48 };
  49
  50 #define MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  51                                                            MODEST_TYPE_SERVER_ACCOUNT_SETTINGS, \
  52                                                            ModestServerAccountSettingsPrivate))
  53
  54 /* globals */
  55 static GObjectClass *parent_class = NULL;
  56
  57 GType
  58 modest_server_account_settings_get_type (void)
  59 {
  60         static GType my_type = 0;
  61
  62         if (!my_type) {
  63                 static const GTypeInfo my_info = {
  64                         sizeof(ModestServerAccountSettingsClass),
  65                         NULL,   /* base init */
  66                         NULL,   /* base finalize */
  67                         (GClassInitFunc) modest_server_account_settings_class_init,
  68                         NULL,   /* class finalize */
  69                         NULL,   /* class data */
  70                         sizeof(ModestServerAccountSettings),
  71                         0,      /* n_preallocs */
  72                         (GInstanceInitFunc) modest_server_account_settings_instance_init,
  73                         NULL
  74                 };
  75
  76                 my_type = g_type_register_static (G_TYPE_OBJECT,
  77                                                   "ModestServerAccountSettings",
  78                                                   &my_info, 0);
  79         }
  80         return my_type;
  81 }
  82
  83 static void
  84 modest_server_account_settings_class_init (ModestServerAccountSettingsClass *klass)
  85 {
  86         GObjectClass *gobject_class;
  87         gobject_class = (GObjectClass *) klass;
  88
  89         parent_class = g_type_class_peek_parent (klass);
  90         gobject_class->finalize = modest_server_account_settings_finalize;
  91
  92         g_type_class_add_private (gobject_class,
  93                                   sizeof(ModestServerAccountSettingsPrivate));
  94 }
  95
  96 static void
  97 modest_server_account_settings_instance_init (ModestServerAccountSettings *obj)
  98 {
  99         ModestServerAccountSettingsPrivate *priv;
 100
 101         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (obj);
 102
 103         priv->hostname = NULL;
 104         priv->protocol = MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
 105         priv->port = 0;
 106         priv->username = NULL;
 107         priv->password = NULL;
 108         priv->security = MODEST_PROTOCOL_CONNECTION_NORMAL;
 109         priv->auth_protocol = MODEST_PROTOCOL_AUTH_NONE;
 110         priv->account_name = NULL;
 111         priv->uri = NULL;
 112 }
 113
 114 static void
 115 modest_server_account_settings_finalize   (GObject *obj)
 116 {
 117         ModestServerAccountSettings *settings = MODEST_SERVER_ACCOUNT_SETTINGS (obj);
 118         ModestServerAccountSettingsPrivate *priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 119         g_free (priv->hostname);
 120         priv->hostname = NULL;
 121         g_free (priv->username);
 122         priv->username = NULL;
 123         g_free (priv->password);
 124         priv->password = NULL;
 125         priv->protocol = MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
 126         priv->port = 0;
 127         priv->security = MODEST_PROTOCOL_CONNECTION_NORMAL;
 128         priv->auth_protocol = MODEST_PROTOCOL_AUTH_NONE;
 129         g_free (priv->account_name);
 130         priv->account_name = NULL;
 131         g_free (priv->uri);
 132         priv->uri = NULL;
 133
 134         G_OBJECT_CLASS (parent_class)->finalize (obj);
 135 }
 136
 137 ModestServerAccountSettings*
 138 modest_server_account_settings_new (void)
 139 {
 140         return g_object_new (MODEST_TYPE_SERVER_ACCOUNT_SETTINGS, NULL);
 141 }
 142
 143 const gchar*
 144 modest_server_account_settings_get_hostname (ModestServerAccountSettings *settings)
 145 {
 146         ModestServerAccountSettingsPrivate *priv;
 147
 148         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), NULL);
 149
 150         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 151         return priv->hostname;
 152 }
 153
 154 void
 155 modest_server_account_settings_set_hostname (ModestServerAccountSettings *settings,
 156                                              const gchar *hostname)
 157 {
 158         ModestServerAccountSettingsPrivate *priv;
 159
 160         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 161
 162         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 163         g_free (priv->hostname);
 164         priv->hostname = g_strdup (hostname);
 165 }
 166
 167 const gchar*
 168 modest_server_account_settings_get_uri (ModestServerAccountSettings *settings)
 169 {
 170         ModestServerAccountSettingsPrivate *priv;
 171
 172         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), NULL);
 173
 174         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 175         return priv->uri;
 176 }
 177
 178 void
 179 modest_server_account_settings_set_uri (ModestServerAccountSettings *settings,
 180                                         const gchar *uri)
 181 {
 182         ModestServerAccountSettingsPrivate *priv;
 183
 184         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 185
 186         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 187         g_free (priv->uri);
 188         priv->uri = g_strdup (uri);
 189
 190         /* we set the protocol to a NULL equivalent value. We should use uri in case
 191          * protocol has this value. */
 192         priv->protocol = MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN;
 193 }
 194
 195 const gchar*
 196 modest_server_account_settings_get_username (ModestServerAccountSettings *settings)
 197 {
 198         ModestServerAccountSettingsPrivate *priv;
 199
 200         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), NULL);
 201
 202         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 203         return priv->username;
 204 }
 205
 206 void
 207 modest_server_account_settings_set_username (ModestServerAccountSettings *settings,
 208                                              const gchar *username)
 209 {
 210         ModestServerAccountSettingsPrivate *priv;
 211
 212         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 213
 214         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 215         g_free (priv->username);
 216         priv->username = g_strdup (username);
 217 }
 218
 219 const gchar*
 220 modest_server_account_settings_get_password (ModestServerAccountSettings *settings)
 221 {
 222         ModestServerAccountSettingsPrivate *priv;
 223
 224         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), NULL);
 225
 226         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 227         return priv->password;
 228 }
 229
 230 void
 231 modest_server_account_settings_set_password (ModestServerAccountSettings *settings,
 232                                              const gchar *password)
 233 {
 234         ModestServerAccountSettingsPrivate *priv;
 235
 236         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 237
 238         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 239         g_free (priv->password);
 240         priv->password = g_strdup (password);
 241 }
 242
 243 const gchar*
 244 modest_server_account_settings_get_account_name (ModestServerAccountSettings *settings)
 245 {
 246         ModestServerAccountSettingsPrivate *priv;
 247
 248         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), NULL);
 249
 250         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 251         return priv->account_name;
 252 }
 253
 254 void
 255 modest_server_account_settings_set_account_name (ModestServerAccountSettings *settings,
 256                                                  const gchar *account_name)
 257 {
 258         ModestServerAccountSettingsPrivate *priv;
 259
 260         /* be careful. This method should only be used internally in #ModestAccountMgr and
 261          * #ModestAccountSettings. */
 262
 263         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 264
 265         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 266         g_free (priv->account_name);
 267         priv->account_name = g_strdup (account_name);
 268 }
 269
 270 ModestTransportStoreProtocol
 271 modest_server_account_settings_get_protocol (ModestServerAccountSettings *settings)
 272 {
 273         ModestServerAccountSettingsPrivate *priv;
 274
 275         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN);
 276
 277         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 278         return priv->protocol;
 279 }
 280
 281 void
 282 modest_server_account_settings_set_protocol (ModestServerAccountSettings *settings,
 283                                              ModestTransportStoreProtocol protocol)
 284 {
 285         ModestServerAccountSettingsPrivate *priv;
 286
 287         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 288
 289         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 290         priv->protocol = protocol;
 291
 292         /* we also set the uri to NULL, as setting a protocol implies disabling uri setting type */
 293         g_free (priv->uri);
 294         priv->uri = NULL;
 295 }
 296
 297 guint
 298 modest_server_account_settings_get_port (ModestServerAccountSettings *settings)
 299 {
 300         ModestServerAccountSettingsPrivate *priv;
 301
 302         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), 0);
 303
 304         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 305         return priv->port;
 306 }
 307
 308 void
 309 modest_server_account_settings_set_port (ModestServerAccountSettings *settings,
 310                                          guint port)
 311 {
 312         ModestServerAccountSettingsPrivate *priv;
 313
 314         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 315
 316         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 317         priv->port = port;
 318 }
 319
 320 ModestConnectionProtocol
 321 modest_server_account_settings_get_security (ModestServerAccountSettings *settings)
 322 {
 323         ModestServerAccountSettingsPrivate *priv;
 324
 325         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), MODEST_PROTOCOL_CONNECTION_NORMAL);
 326
 327         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 328         return priv->security;
 329 }
 330
 331 void
 332 modest_server_account_settings_set_security (ModestServerAccountSettings *settings,
 333                                              ModestConnectionProtocol security)
 334 {
 335         ModestServerAccountSettingsPrivate *priv;
 336
 337         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 338
 339         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 340         priv->security = security;
 341 }
 342
 343 ModestAuthProtocol
 344 modest_server_account_settings_get_auth_protocol (ModestServerAccountSettings *settings)
 345 {
 346         ModestServerAccountSettingsPrivate *priv;
 347
 348         g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), MODEST_PROTOCOL_AUTH_NONE);
 349
 350         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 351         return priv->auth_protocol;
 352 }
 353
 354 void
 355 modest_server_account_settings_set_auth_protocol (ModestServerAccountSettings *settings,
 356                                                   ModestAuthProtocol auth_protocol)
 357 {
 358         ModestServerAccountSettingsPrivate *priv;
 359
 360         g_return_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings));
 361
 362         priv = MODEST_SERVER_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 363         priv->auth_protocol = auth_protocol;
 364 }
 365