+ modest_account_mgr_set_bool (self, account_name, MODEST_ACCOUNT_USERNAME_HAS_SUCCEEDED,
+ succeeded, TRUE /* server account */);
+}
+
+gchar*
+modest_account_mgr_get_server_account_password (ModestAccountMgr *self, const gchar* account_name)
+{
+ return modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
+ TRUE /* server account */);
+}
+
+gboolean
+modest_account_mgr_get_server_account_has_password (ModestAccountMgr *self, const gchar* account_name)
+{
+ gboolean result = FALSE;
+ gchar *password = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
+ TRUE /* server account */);
+ if (password && strlen (password)) {
+ result = TRUE;
+
+ /* Clean password */
+ bzero (password, strlen (password));
+ }
+
+ g_free (password);
+ return result;
+}
+
+
+gchar*
+modest_account_mgr_get_server_account_hostname (ModestAccountMgr *self,
+ const gchar* account_name)
+{
+ return modest_account_mgr_get_string (self,
+ account_name,
+ MODEST_ACCOUNT_HOSTNAME,
+ TRUE /* server account */);
+}
+
+void
+modest_account_mgr_set_server_account_hostname (ModestAccountMgr *self,
+ const gchar *server_account_name,
+ const gchar *hostname)
+{
+ modest_account_mgr_set_string (self,
+ server_account_name,
+ MODEST_ACCOUNT_HOSTNAME,
+ hostname,
+ TRUE /* server account */);
+}
+
+
+
+ModestProtocolType
+modest_account_mgr_get_server_account_secure_auth (ModestAccountMgr *self,
+ const gchar* account_name)
+{
+ ModestProtocolRegistry *protocol_registry;
+ ModestProtocolType result = MODEST_PROTOCOLS_AUTH_NONE;
+ gchar* value;
+
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH,
+ TRUE /* server account */);
+ if (value) {
+ ModestProtocol *protocol;
+
+ protocol = modest_protocol_registry_get_protocol_by_name (protocol_registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS, value);
+ g_free (value);
+
+ if (protocol)
+ result = modest_protocol_get_type_id (protocol);
+
+ }
+
+ return result;
+}
+
+
+void
+modest_account_mgr_set_server_account_secure_auth (ModestAccountMgr *self,
+ const gchar* account_name, ModestProtocolType secure_auth)
+{
+ const gchar* str_value;
+ ModestProtocolRegistry *protocol_registry;
+ ModestProtocol *protocol;
+
+ /* Get the conf string for the protocol: */
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, secure_auth);
+ str_value = modest_protocol_get_name (protocol);
+
+ /* Set it in the configuration: */
+ modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH, str_value, TRUE);
+}
+
+ModestProtocolType
+modest_account_mgr_get_server_account_security (ModestAccountMgr *self,
+ const gchar* account_name)
+{
+ ModestProtocolType result = MODEST_PROTOCOLS_CONNECTION_NONE;
+ gchar* value;
+
+ value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_SECURITY,
+ TRUE /* server account */);
+ if (value) {
+ ModestProtocolRegistry *protocol_registry;
+ ModestProtocol *protocol;
+
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ protocol = modest_protocol_registry_get_protocol_by_name (protocol_registry,
+ MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
+ value);
+ g_free (value);
+
+ if (protocol)
+ result = modest_protocol_get_type_id (protocol);
+ }
+
+ return result;
+}
+
+void
+modest_account_mgr_set_server_account_security (ModestAccountMgr *self,
+ const gchar* account_name,
+ ModestProtocolType security)
+{
+ const gchar* str_value;
+ ModestProtocolRegistry *protocol_registry;
+ ModestProtocol *protocol;
+
+ /* Get the conf string for the protocol type: */
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, security);
+ str_value = modest_protocol_get_name (protocol);
+
+ /* Set it in the configuration: */
+ modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_SECURITY, str_value, TRUE);
+}
+
+ModestServerAccountSettings*
+modest_account_mgr_load_server_settings (ModestAccountMgr *self, const gchar* name, gboolean is_transport_and_not_store)
+{
+ ModestServerAccountSettings *settings;
+ ModestProtocol *protocol;
+ ModestProtocolRegistry *registry;
+ gchar *string;
+
+ g_return_val_if_fail (modest_account_mgr_account_exists (self, name, TRUE), NULL);
+ registry = modest_runtime_get_protocol_registry ();
+ settings = modest_server_account_settings_new ();
+
+ modest_server_account_settings_set_account_name (settings, name);
+
+ string = modest_account_mgr_get_string (self, name,
+ MODEST_ACCOUNT_HOSTNAME,TRUE);
+ modest_server_account_settings_set_hostname (settings, string);
+ g_free (string);
+
+ string = modest_account_mgr_get_string (self, name,
+ MODEST_ACCOUNT_USERNAME,TRUE);
+ modest_server_account_settings_set_username (settings, string);
+ g_free (string);
+
+ string = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_PROTO, TRUE);
+ if (is_transport_and_not_store) {
+ protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS, string);
+ } else {
+ protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS, string);
+ }
+ modest_server_account_settings_set_protocol (settings,
+ modest_protocol_get_type_id (protocol));
+ g_free (string);
+
+ modest_server_account_settings_set_port (settings,
+ modest_account_mgr_get_int (self, name, MODEST_ACCOUNT_PORT, TRUE));
+
+ string = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
+ if (string) {
+ protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS, string);
+ modest_server_account_settings_set_auth_protocol (settings,
+ modest_protocol_get_type_id (protocol));
+ g_free (string);
+ } else {
+ modest_server_account_settings_set_auth_protocol (settings, MODEST_PROTOCOLS_AUTH_NONE);
+ }
+
+ string = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_SECURITY, TRUE);
+ if (string) {
+ protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS, string);
+ modest_server_account_settings_set_security_protocol (settings,
+ modest_protocol_get_type_id (protocol));
+ g_free (string);
+ } else {
+ modest_server_account_settings_set_security_protocol (settings,
+ MODEST_PROTOCOLS_CONNECTION_NONE);
+ }
+
+ string = modest_account_mgr_get_string (self, name,
+ MODEST_ACCOUNT_PASSWORD, TRUE);
+ modest_server_account_settings_set_password (settings, string);
+ g_free (string);
+
+ string = modest_account_mgr_get_string (self, name,
+ MODEST_ACCOUNT_URI, TRUE);
+ modest_server_account_settings_set_uri (settings, string);
+ g_free (string);
+
+ return settings;
+}
+
+gboolean
+modest_account_mgr_save_server_settings (ModestAccountMgr *self,
+ ModestServerAccountSettings *settings)
+{
+ gboolean has_errors = FALSE;
+ const gchar *account_name;
+ const gchar *protocol_name;
+ const gchar *uri;
+ ModestProtocolRegistry *protocol_registry;
+ ModestProtocol *protocol;
+
+ g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), FALSE);
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ account_name = modest_server_account_settings_get_account_name (settings);
+
+ /* if we don't have a valid account name we cannot save */
+ g_return_val_if_fail (account_name, FALSE);
+
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
+ modest_server_account_settings_get_protocol (settings));
+ protocol_name = modest_protocol_get_name (protocol);
+ uri = modest_server_account_settings_get_uri (settings);
+ if (!uri) {
+ const gchar *hostname;
+ const gchar *username;
+ const gchar *password;
+ gint port;
+ const gchar *auth_protocol_name;
+ const gchar *security_name;
+
+ hostname = null_means_empty (modest_server_account_settings_get_hostname (settings));
+ username = null_means_empty (modest_server_account_settings_get_username (settings));
+ password = null_means_empty (modest_server_account_settings_get_password (settings));
+ port = modest_server_account_settings_get_port (settings);
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
+ modest_server_account_settings_get_auth_protocol (settings));
+ auth_protocol_name = modest_protocol_get_name (protocol);
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
+ modest_server_account_settings_get_security_protocol (settings));
+ security_name = modest_protocol_get_name (protocol);
+
+ has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_HOSTNAME,
+ hostname, TRUE);
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_USERNAME,
+ username, TRUE));
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
+ password, TRUE));
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PROTO,
+ protocol_name, TRUE));
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_int (self, account_name, MODEST_ACCOUNT_PORT,
+ port, TRUE));
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name,
+ MODEST_ACCOUNT_AUTH_MECH,
+ auth_protocol_name, TRUE));
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_SECURITY,
+ security_name,
+ TRUE));
+ } else {
+ const gchar *uri = modest_server_account_settings_get_uri (settings);
+ has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_URI,
+ uri, TRUE);
+ if (!has_errors)
+ (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PROTO,
+ protocol_name, TRUE));
+ }
+
+ return !has_errors;
+
+}
+
+
+ModestAccountSettings *
+modest_account_mgr_load_account_settings (ModestAccountMgr *self,
+ const gchar* name)
+{
+ ModestAccountSettings *settings;
+ gchar *string;