callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Redo this a lot so that instead of having a class full of callbacks, we

Browse Source 
* camel-session.c: Redo this a lot so that instead of having a
	class full of callbacks, we have a subclassable class. Also,
	replace the increasingly horrifying
	camel_session_query_authenticator with three new routines,
	camel_session_get_password, camel_session_forget_password, and
	camel_session_alert_user.

	* camel-pgp-context.c:
	* camel-pkcs7-context.c:
	* camel-smime-context.c:
	* providers/imap/camel-imap-store.c:
	* providers/pop3/camel-pop3-store.c:
	* providers/smtp/camel-smtp-transport.c:
	Use camel_session_get_password / camel_session_forget_password.

	* camel-tcp-stream-ssl.c (ssl_bad_cert): Use
	camel_session_alert_user.

svn path=/trunk/; revision=9617
This commit is contained in:
Dan Winship
2001-04-27 21:08:08 +00:00
parent d06ca412e4
commit 63e96e1002
10 changed files with 371 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
camel/ChangeLog
View File

@ -1,3 +1,23 @@
2001-04-27 Dan Winship <danw@ximian.com>
* camel-session.c: Redo this a lot so that instead of having a
class full of callbacks, we have a subclassable class. Also,
replace the increasingly horrifying
camel_session_query_authenticator with three new routines,
camel_session_get_password, camel_session_forget_password, and
camel_session_alert_user.
* camel-pgp-context.c:
* camel-pkcs7-context.c:
* camel-smime-context.c:
* providers/imap/camel-imap-store.c:
* providers/pop3/camel-pop3-store.c:
* providers/smtp/camel-smtp-transport.c:
Use camel_session_get_password / camel_session_forget_password.
* camel-tcp-stream-ssl.c (ssl_bad_cert): Use
camel_session_alert_user.
2001-04-26 Jeffrey Stedfast <fejj@ximian.com> 2001-04-26 Jeffrey Stedfast <fejj@ximian.com>
* camel.c (camel_init): Automagically call camel_shutdown() * camel.c (camel_init): Automagically call camel_shutdown()

10
camel/camel-pgp-context.c
View File

@ -192,9 +192,9 @@ pgp_get_passphrase (CamelSession *session, CamelPgpType pgp_type, char *userid)
type); type);
/* Use the userid as a key if possible, else be generic and use the type */ /* Use the userid as a key if possible, else be generic and use the type */
passphrase = camel_session_query_authenticator (session, CAMEL_AUTHENTICATOR_ASK, passphrase = camel_session_get_password (session, prompt, TRUE,
prompt, TRUE, NULL, userid ? userid : (char *) type, NULL, userid ? userid : type,
NULL); NULL);
g_free (prompt); g_free (prompt);
return passphrase; return passphrase;
@ -208,9 +208,7 @@ pgp_forget_passphrase (CamelSession *session, CamelPgpType pgp_type, char *useri
if (!userid) if (!userid)
type = pgp_get_type_as_string (pgp_type); type = pgp_get_type_as_string (pgp_type);
camel_session_query_authenticator (session, CAMEL_AUTHENTICATOR_TELL, camel_session_forget_password (session, NULL, userid ? userid : type, NULL);
NULL, FALSE, NULL, userid ? userid : (char *) type,
NULL);
} }
static int static int

5
camel/camel-pkcs7-context.c
View File

@ -195,9 +195,8 @@ get_password (void *arg, SECKEYKeyDBHandle *handle)
return pwitem; return pwitem;
prompt = g_strdup_printf (_("Please enter your password for %s"), userid); prompt = g_strdup_printf (_("Please enter your password for %s"), userid);
passwd = camel_session_query_authenticator (session, CAMEL_AUTHENTICATOR_ASK, passwd = camel_session_get_password (session, prompt, TRUE,
prompt, TRUE, NULL, userid, NULL, userid, NULL);
NULL);
g_free (prompt); g_free (prompt);
/* hash the password */ /* hash the password */

426
camel/camel-session.c
View File

@ -2,13 +2,12 @@
/* camel-session.c : Abstract class for an email session */ /* camel-session.c : Abstract class for an email session */
/* /*
* * Authors:
* Author: * Dan Winship <danw@ximian.com>
* Jeffrey Stedfast <fejj@ximian.com>
* Bertrand Guiheneuf <bertrand@helixcode.com> * Bertrand Guiheneuf <bertrand@helixcode.com>
* Dan Winship <danw@helixcode.com>
* Jeffrey Stedfast <fejj@helixcode.com>
* *
* Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com) * Copyright 1999 - 2001 Ximian, Inc.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as * modify it under the terms of the GNU General Public License as
@ -46,9 +45,22 @@
#include "camel-private.h" #include "camel-private.h"
#define d(x) #define CS_CLASS(so) CAMEL_SESSION_CLASS (CAMEL_OBJECT_GET_CLASS (so))
static void register_provider (CamelSession *session, CamelProvider *provider);
static GList *list_providers (CamelSession *session, gboolean load);
static CamelProvider *get_provider (CamelSession *session,
const char *url_string,
CamelException *ex);
static CamelService *get_service (CamelSession *session,
const char *url_string,
CamelProviderType type,
CamelException *ex);
static char *get_storage_path (CamelSession *session,
CamelService *service,
CamelException *ex);
static CamelObjectClass *parent_class;
/* The vfolder provider is always avilable */ /* The vfolder provider is always avilable */
static CamelProvider vee_provider = { static CamelProvider vee_provider = {
@ -107,7 +119,15 @@ camel_session_finalise (CamelObject *o)
static void static void
camel_session_class_init (CamelSessionClass *camel_session_class) camel_session_class_init (CamelSessionClass *camel_session_class)
{ {
parent_class = camel_type_get_global_classfuncs (camel_object_get_type ()); /* virtual method definition */
camel_session_class->register_provider = register_provider;
camel_session_class->list_providers = list_providers;
camel_session_class->get_provider = get_provider;
camel_session_class->get_service = get_service;
camel_session_class->get_storage_path = get_storage_path;
vee_provider.object_types[CAMEL_PROVIDER_STORE] = camel_vee_store_get_type ();
vee_provider.service_cache = g_hash_table_new (camel_url_hash, camel_url_equal);
} }
CamelType CamelType
@ -116,50 +136,39 @@ camel_session_get_type (void)
static CamelType camel_session_type = CAMEL_INVALID_TYPE; static CamelType camel_session_type = CAMEL_INVALID_TYPE;
if (camel_session_type == CAMEL_INVALID_TYPE) { if (camel_session_type == CAMEL_INVALID_TYPE) {
camel_session_type = camel_type_register (camel_object_get_type (), "CamelSession", camel_session_type = camel_type_register (
sizeof (CamelSession), camel_object_get_type (), "CamelSession",
sizeof (CamelSessionClass), sizeof (CamelSession),
(CamelObjectClassInitFunc) camel_session_class_init, sizeof (CamelSessionClass),
NULL, (CamelObjectClassInitFunc) camel_session_class_init,
(CamelObjectInitFunc) camel_session_init, NULL,
(CamelObjectFinalizeFunc) camel_session_finalise); (CamelObjectInitFunc) camel_session_init,
(CamelObjectFinalizeFunc) camel_session_finalise);
} }
return camel_session_type; return camel_session_type;
} }
/** /**
* camel_session_new: * camel_session_construct:
* @storage_path: Path to a directory Camel can use for persistent storage. * @session: a session object to construct
* (This directory must already exist.) * @storage_path: path to a directory the session can use for
* @authenticator: A callback for discussing authentication information * persistent storage. (This directory must already exist.)
* @registrar: A callback for registering timeout callbacks
* @remove: A callback for removing timeout callbacks
* *
* This creates a new CamelSession object, which represents global state * Constructs @session.
* for the Camel library, and contains callbacks that can be used to
* interact with the main application.
*
* Return value: the new CamelSession
**/ **/
CamelSession * void
camel_session_new (const char *storage_path, camel_session_construct (CamelSession *session, const char *storage_path)
CamelAuthCallback authenticator,
CamelTimeoutRegisterCallback registrar,
CamelTimeoutRemoveCallback remover)
{ {
CamelSession *session = CAMEL_SESSION (camel_object_new (CAMEL_SESSION_TYPE));
session->storage_path = g_strdup (storage_path); session->storage_path = g_strdup (storage_path);
session->authenticator = authenticator;
session->registrar = registrar;
session->remover = remover;
vee_provider.object_types[CAMEL_PROVIDER_STORE] = camel_vee_store_get_type();
vee_provider.service_cache = g_hash_table_new(camel_url_hash, camel_url_equal);
camel_session_register_provider(session, &vee_provider); camel_session_register_provider(session, &vee_provider);
}
return session;
static void
register_provider (CamelSession *session, CamelProvider *provider)
{
g_hash_table_insert (session->providers, provider->protocol, provider);
} }
/** /**
@ -180,9 +189,10 @@ camel_session_register_provider (CamelSession *session,
g_return_if_fail (CAMEL_IS_SESSION (session)); g_return_if_fail (CAMEL_IS_SESSION (session));
g_return_if_fail (provider != NULL); g_return_if_fail (provider != NULL);
g_hash_table_insert (session->providers, provider->protocol, provider); CS_CLASS (session)->register_provider (session, provider);
} }
static void static void
ensure_loaded (gpointer key, gpointer value, gpointer user_data) ensure_loaded (gpointer key, gpointer value, gpointer user_data)
{ {
@ -217,6 +227,18 @@ add_to_list (gpointer key, gpointer value, gpointer user_data)
*list = g_list_insert_sorted (*list, prov, provider_compare); *list = g_list_insert_sorted (*list, prov, provider_compare);
} }
static GList *
list_providers (CamelSession *session, gboolean load)
{
GList *list = NULL;
if (load)
g_hash_table_foreach (session->modules, ensure_loaded, session);
g_hash_table_foreach (session->providers, add_to_list, &list);
return list;
}
/** /**
* camel_session_list_providers: * camel_session_list_providers:
* @session: the session * @session: the session
@ -235,24 +257,21 @@ camel_session_list_providers (CamelSession *session, gboolean load)
g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL); g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
CAMEL_SESSION_LOCK(session, lock); CAMEL_SESSION_LOCK (session, lock);
list = CS_CLASS (session)->list_providers (session, load);
if (load) CAMEL_SESSION_UNLOCK (session, lock);
g_hash_table_foreach (session->modules, ensure_loaded, session);
list = NULL;
g_hash_table_foreach (session->providers, add_to_list, &list);
CAMEL_SESSION_UNLOCK(session, lock);
return list; return list;
} }
static CamelProvider * static CamelProvider *
get_provider_locked (CamelSession *session, const char *protocol, get_provider (CamelSession *session, const char *url_string, CamelException *ex)
CamelException *ex)
{ {
CamelProvider *provider; CamelProvider *provider;
char *protocol;
protocol = g_strndup (url_string, strcspn (url_string, ":"));
provider = g_hash_table_lookup (session->providers, protocol); provider = g_hash_table_lookup (session->providers, protocol);
if (!provider) { if (!provider) {
@ -262,8 +281,10 @@ get_provider_locked (CamelSession *session, const char *protocol,
path = g_hash_table_lookup (session->modules, protocol); path = g_hash_table_lookup (session->modules, protocol);
if (path) { if (path) {
camel_provider_load (session, path, ex); camel_provider_load (session, path, ex);
if (camel_exception_is_set (ex)) if (camel_exception_is_set (ex)) {
g_free (protocol);
return NULL; return NULL;
}
} }
provider = g_hash_table_lookup (session->providers, protocol); provider = g_hash_table_lookup (session->providers, protocol);
} }
@ -273,6 +294,7 @@ get_provider_locked (CamelSession *session, const char *protocol,
_("No provider available for protocol `%s'"), _("No provider available for protocol `%s'"),
protocol); protocol);
} }
g_free (protocol);
return provider; return provider;
} }
@ -293,13 +315,10 @@ camel_session_get_provider (CamelSession *session, const char *url_string,
CamelException *ex) CamelException *ex)
{ {
CamelProvider *provider; CamelProvider *provider;
char *protocol;
protocol = g_strndup (url_string, strcspn (url_string, ":")); CAMEL_SESSION_LOCK (session, lock);
CAMEL_SESSION_LOCK(session, lock); provider = CS_CLASS (session)->get_provider (session, url_string, ex);
provider = get_provider_locked (session, protocol, ex); CAMEL_SESSION_UNLOCK (session, lock);
CAMEL_SESSION_UNLOCK(session, lock);
g_free (protocol);
return provider; return provider;
} }
@ -323,6 +342,54 @@ service_cache_remove (CamelService *service, gpointer event_data, gpointer user_
CAMEL_SESSION_UNLOCK(session, lock); CAMEL_SESSION_UNLOCK(session, lock);
} }
static CamelService *
get_service (CamelSession *session, const char *url_string,
CamelProviderType type, CamelException *ex)
{
CamelURL *url;
CamelProvider *provider;
CamelService *service;
url = camel_url_new (url_string, ex);
if (!url)
return NULL;
/* We need to look up the provider so we can then lookup
the service in the provider's cache */
provider = CS_CLASS (session)->get_provider (session, url->protocol, ex);
if (provider && !provider->object_types[type]) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_URL_INVALID,
_("No provider available for protocol `%s'"),
url->protocol);
provider = NULL;
}
if (!provider) {
camel_url_free (url);
return NULL;
}
/* Now look up the service in the provider's cache */
service = g_hash_table_lookup (provider->service_cache, url);
if (service != NULL) {
camel_url_free (url);
camel_object_ref (CAMEL_OBJECT (service));
return service;
}
service = (CamelService *)camel_object_new (provider->object_types[type]);
camel_service_construct (service, session, provider, url, ex);
if (camel_exception_is_set (ex)) {
camel_object_unref (CAMEL_OBJECT (service));
service = NULL;
} else {
g_hash_table_insert (provider->service_cache, url, service);
camel_object_hook_event (CAMEL_OBJECT (service), "finalize", (CamelObjectEventHookFunc) service_cache_remove, session);
}
return service;
}
/** /**
* camel_session_get_service: * camel_session_get_service:
* @session: the CamelSession * @session: the CamelSession
@ -346,49 +413,14 @@ CamelService *
camel_session_get_service (CamelSession *session, const char *url_string, camel_session_get_service (CamelSession *session, const char *url_string,
CamelProviderType type, CamelException *ex) CamelProviderType type, CamelException *ex)
{ {
CamelURL *url;
CamelProvider *provider;
CamelService *service; CamelService *service;
url = camel_url_new (url_string, ex); g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
if (!url) g_return_val_if_fail (url_string != NULL, NULL);
return NULL;
/* We need to look up the provider so we can then lookup CAMEL_SESSION_LOCK (session, lock);
the service in the provider's cache */ service = CS_CLASS (session)->get_service (session, url_string, type, ex);
CAMEL_SESSION_LOCK(session, lock); CAMEL_SESSION_UNLOCK (session, lock);
provider = get_provider_locked (session, url->protocol, ex);
if (provider && !provider->object_types[type]) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_URL_INVALID,
_("No provider available for protocol `%s'"),
url->protocol);
provider = NULL;
}
if (!provider) {
camel_url_free (url);
CAMEL_SESSION_UNLOCK(session, lock);
return NULL;
}
/* Now look up the service in the provider's cache */
service = g_hash_table_lookup (provider->service_cache, url);
if (service != NULL) {
camel_url_free (url);
camel_object_ref (CAMEL_OBJECT (service));
CAMEL_SESSION_UNLOCK(session, lock);
return service;
}
service = (CamelService *)camel_object_new (provider->object_types[type]);
camel_service_construct (service, session, provider, url, ex);
if (camel_exception_is_set (ex)) {
camel_object_unref (CAMEL_OBJECT (service));
service = NULL;
} else {
g_hash_table_insert (provider->service_cache, url, service);
camel_object_hook_event (CAMEL_OBJECT (service), "finalize", (CamelObjectEventHookFunc) service_cache_remove, session);
}
CAMEL_SESSION_UNLOCK(session, lock);
return service; return service;
} }
@ -429,24 +461,8 @@ camel_session_get_service_connected (CamelSession *session,
} }
/** static char *
* camel_session_get_storage_path: get_storage_path (CamelSession *session, CamelService *service, CamelException *ex)
* @session: session object
* @service: a CamelService
* @ex: a CamelException
*
* This returns the path to a directory which the service can use for
* its own purposes. Data stored there will remain between Evolution
* sessions. No code outside of that service should ever touch the
* files in this directory. If the directory does not exist, it will
* be created.
*
* Return value: the path (which the caller must free), or %NULL if
* an error occurs.
**/
char *
camel_session_get_storage_path (CamelSession *session, CamelService *service,
CamelException *ex)
{ {
char *path, *p; char *path, *p;
@ -469,70 +485,133 @@ camel_session_get_storage_path (CamelSession *session, CamelService *service,
} }
/** /**
* camel_session_query_authenticator: query the session authenticator * camel_session_get_storage_path:
* @session: session object * @session: session object
* @mode: %CAMEL_AUTHENTICATOR_ASK, %CAMEL_AUTHENTICATOR_TELL or CAMEL_AUTHENTICATOR_ACCEPT * @service: a CamelService
* @data: prompt to query user with, or data to cache
* @secret: whether or not the data is secret (eg, a password)
* @service: the service this query is being made by
* @item: an identifier, unique within this service, for the information
* @ex: a CamelException * @ex: a CamelException
* *
* This function is used by a CamelService to discuss authentication * This returns the path to a directory which the service can use for
* information with the application. * its own purposes. Data stored there will remain between Evolution
* sessions. No code outside of that service should ever touch the
* files in this directory. If the directory does not exist, it will
* be created.
* *
* @service and @item together uniquely identify the piece of data the * Return value: the path (which the caller must free), or %NULL if
* caller is concerned with. * an error occurs.
*
* If @mode is %CAMEL_AUTHENTICATOR_ASK, then @data is a question to
* ask the user (if the application doesn't already have the answer
* cached). If @secret is set, the user's input should not be echoed
* back. The authenticator should set @ex to
* %CAMEL_EXCEPTION_USER_CANCEL if the user did not provide the
* information. The caller must g_free() the information returned when
* it is done with it.
*
* If @mode is %CAMEL_AUTHENTICATOR_TELL, then @data is information
* that the application should cache, or %NULL if it should stop
* caching anything about that datum (eg, because the data is a
* password that turned out to be incorrect).
*
* If @mode is %CAMEL_AUTHENTICATOR_ACCEPT, then @data is a YES/NO
* question to ask the user (if the application doesn't already have
* the answer cached). Return GINT_TO_POINTER(TRUE) on accept, or
* GINT_TO_POINTER(FALSE) to decline.
*
* Return value: the authentication information or %NULL.
**/ **/
gpointer char *
camel_session_query_authenticator (CamelSession *session, camel_session_get_storage_path (CamelSession *session, CamelService *service,
CamelAuthCallbackMode mode, CamelException *ex)
char *prompt, gboolean secret,
CamelService *service, char *item,
CamelException *ex)
{ {
return session->authenticator (mode, prompt, secret, g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
service, item, ex); g_return_val_if_fail (CAMEL_IS_SERVICE (service), NULL);
return CS_CLASS (session)->get_storage_path (session, service, ex);
} }
/** /**
* camel_session_register_timeout: Register a timeout to be called * camel_session_get_password:
* periodically. * @session: session object
* @prompt: prompt to provide to user
* @secret: whether or not the data is secret (eg, a password, as opposed
* to a smartcard response)
* @service: the service this query is being made by
* @item: an identifier, unique within this service, for the information
* @ex: a CamelException
* *
* This function is used by a CamelService to ask the application and
* the user for a password or other authentication data.
*
* @service and @item together uniquely identify the piece of data the
* caller is concerned with.
*
* @prompt is a question to ask the user (if the application doesn't
* already have the answer cached). If @secret is set, the user's
* input will not be echoed back. The authenticator should set @ex
* to %CAMEL_EXCEPTION_USER_CANCEL if the user did not provide the
* information. The caller must g_free() the information returned when
* it is done with it.
*
* Return value: the authentication information or %NULL.
**/
char *
camel_session_get_password (CamelSession *session, const char *prompt,
gboolean secret, CamelService *service,
const char *item, CamelException *ex)
{
g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
g_return_val_if_fail (CAMEL_IS_SERVICE (service), NULL);
g_return_val_if_fail (prompt != NULL, NULL);
g_return_val_if_fail (item != NULL, NULL);
return CS_CLASS (session)->get_password (session, prompt, secret, service, item, ex);
}
/**
* camel_session_forget_password:
* @session: session object
* @service: the service rejecting the password
* @item: an identifier, unique within this service, for the information
* @ex: a CamelException
*
* This function is used by a CamelService to tell the application
* that the authentication information it provided via
* camel_session_get_password was rejected by the service. If the
* application was caching this information, it should stop,
* and if the service asks for it again, it should ask the user.
*
* @service and @item identify the rejected authentication information,
* as with camel_session_get_password.
**/
void
camel_session_forget_password (CamelSession *session, CamelService *service,
const char *item, CamelException *ex)
{
g_return_if_fail (CAMEL_IS_SESSION (session));
g_return_if_fail (CAMEL_IS_SERVICE (service));
g_return_if_fail (item != NULL);
CS_CLASS (session)->forget_password (session, service, item, ex);
}
/**
* camel_session_alert_user:
* @session: session object
* @type: the type of alert (info, warning, or error)
* @prompt: the message for the user
* @cancel: whether or not to provide a "Cancel" option in addition to
* an "OK" option.
*
* Presents the given @prompt to the user, in the style indicated by
* @type. If @cancel is %TRUE, the user will be able to accept or
* cancel. Otherwise, the message is purely informational.
*
* Return value: %TRUE if the user accepts, %FALSE if they cancel.
*/
gboolean
camel_session_alert_user (CamelSession *session, CamelSessionAlertType type,
const char *prompt, gboolean cancel)
{
g_return_val_if_fail (CAMEL_IS_SESSION (session), FALSE);
g_return_val_if_fail (prompt != NULL, FALSE);
return CS_CLASS (session)->alert_user (session, type, prompt, cancel);
}
/**
* camel_session_register_timeout:
* @session: the CamelSession * @session: the CamelSession
* @interval: the number of milliseconds interval between calls * @interval: the number of milliseconds interval between calls
* @callback: the function to call * @callback: the function to call
* @user_data: extra data to be passed to the callback * @user_data: extra data to be passed to the callback
* *
* This function will use the registrar callback provided upon * Registers the given timeout. @callback will be called every
* camel_session_new to register the timeout. The callback will * @interval milliseconds with one argument, @user_data, until it
* be called every @interval milliseconds until it returns @FALSE. * returns %FALSE.
* It will be passed one argument, @user_data.
* *
* Returns a nonzero handle that can be used with * Return value: On success, a non-zero handle that can be used with
* camel_session_remove_timeout on success, and 0 on failure to * camel_session_remove_timeout(). On failure, 0.
* register the timeout.
**/ **/
guint guint
camel_session_register_timeout (CamelSession *session, camel_session_register_timeout (CamelSession *session,
@ -540,25 +619,24 @@ camel_session_register_timeout (CamelSession *session,
CamelTimeoutCallback callback, CamelTimeoutCallback callback,
gpointer user_data) gpointer user_data)
{ {
g_return_val_if_fail (CAMEL_IS_SESSION (session), FALSE); g_return_val_if_fail (CAMEL_IS_SESSION (session), 0);
return session->registrar (interval, callback, user_data); return CS_CLASS (session)->register_timeout (session, interval, callback, user_data);
} }
/** /**
* camel_session_remove_timeout: Remove a previously registered * camel_session_remove_timeout:
* timeout.
*
* @session: the CamelSession * @session: the CamelSession
* @handle: a value returned from camel_session_register_timeout * @handle: a value returned from camel_session_register_timeout()
* *
* This function will use the remover callback provided upon * Removes the indicated timeout.
* camel_session_new to remove the timeout.
* *
* Returns TRUE on success and FALSE on failure. * Return value: %TRUE on success, %FALSE on failure.
**/ **/
gboolean gboolean
camel_session_remove_timeout (CamelSession *session, guint handle) camel_session_remove_timeout (CamelSession *session, guint handle)
{ {
return session->remover (handle); g_return_val_if_fail (CAMEL_IS_SESSION (session), FALSE);
return CS_CLASS (session)->remove_timeout (session, handle);
} }

137
camel/camel-session.h
View File

@ -43,22 +43,12 @@ extern "C" {
#define CAMEL_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_SESSION_TYPE)) #define CAMEL_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_SESSION_TYPE))
typedef enum {
CAMEL_AUTHENTICATOR_ASK,
CAMEL_AUTHENTICATOR_TELL,
CAMEL_AUTHENTICATOR_ACCEPT
} CamelAuthCallbackMode;
typedef gpointer (*CamelAuthCallback) (CamelAuthCallbackMode mode,
char *data, gboolean secret,
CamelService *service, char *item,
CamelException *ex);
typedef gboolean (*CamelTimeoutCallback) (gpointer data); typedef gboolean (*CamelTimeoutCallback) (gpointer data);
typedef guint (*CamelTimeoutRegisterCallback) (guint32 interval, typedef enum {
CamelTimeoutCallback cb, CAMEL_SESSION_ALERT_INFO,
gpointer camel_data); CAMEL_SESSION_ALERT_WARNING,
typedef gboolean (*CamelTimeoutRemoveCallback) (guint id); CAMEL_SESSION_ALERT_ERROR
} CamelSessionAlertType;
struct _CamelSession struct _CamelSession
{ {
@ -66,16 +56,50 @@ struct _CamelSession
struct _CamelSessionPrivate *priv; struct _CamelSessionPrivate *priv;
char *storage_path; char *storage_path;
CamelAuthCallback authenticator;
CamelTimeoutRegisterCallback registrar;
CamelTimeoutRemoveCallback remover;
GHashTable *providers, *modules; GHashTable *providers, *modules;
}; };
typedef struct { typedef struct {
CamelObjectClass parent_class; CamelObjectClass parent_class;
void (*register_provider) (CamelSession *session,
CamelProvider *provider);
GList * (*list_providers) (CamelSession *session,
gboolean load);
CamelProvider * (*get_provider) (CamelSession *session,
const char *url_string,
CamelException *ex);
CamelService * (*get_service) (CamelSession *session,
const char *url_string,
CamelProviderType type,
CamelException *ex);
char * (*get_storage_path) (CamelSession *session,
CamelService *service,
CamelException *ex);
char * (*get_password) (CamelSession *session,
const char *prompt,
gboolean secret,
CamelService *service,
const char *item,
CamelException *ex);
void (*forget_password) (CamelSession *session,
CamelService *service,
const char *item,
CamelException *ex);
gboolean (*alert_user) (CamelSession *session,
CamelSessionAlertType type,
const char *prompt,
gboolean cancel);
guint (*register_timeout) (CamelSession *session,
guint32 interval,
CamelTimeoutCallback callback,
gpointer user_data);
gboolean (*remove_timeout) (CamelSession *session,
guint handle);
} CamelSessionClass; } CamelSessionClass;
@ -85,53 +109,58 @@ typedef struct {
CamelType camel_session_get_type (void); CamelType camel_session_get_type (void);
CamelSession * camel_session_new (const char *storage_path, void camel_session_construct (CamelSession *session,
CamelAuthCallback authenticator, const char *storage_path);
CamelTimeoutRegisterCallback registrar,
CamelTimeoutRemoveCallback remover);
void camel_session_register_provider (CamelSession *session, void camel_session_register_provider (CamelSession *session,
CamelProvider *provider); CamelProvider *provider);
GList * camel_session_list_providers (CamelSession *session, GList * camel_session_list_providers (CamelSession *session,
gboolean load); gboolean load);
CamelProvider * camel_session_get_provider (CamelSession *session, CamelProvider * camel_session_get_provider (CamelSession *session,
const char *url_string, const char *url_string,
CamelException *ex); CamelException *ex);
CamelService * camel_session_get_service (CamelSession *session, CamelService * camel_session_get_service (CamelSession *session,
const char *url_string, const char *url_string,
CamelProviderType type, CamelProviderType type,
CamelException *ex); CamelException *ex);
CamelService * camel_session_get_service_connected (CamelSession *session, CamelService * camel_session_get_service_connected (CamelSession *session,
const char *url_string, const char *url_string,
CamelProviderType type, CamelProviderType type,
CamelException *ex); CamelException *ex);
#define camel_session_get_store(session, url_string, ex) \ #define camel_session_get_store(session, url_string, ex) \
((CamelStore *) camel_session_get_service_connected (session, url_string, CAMEL_PROVIDER_STORE, ex)) ((CamelStore *) camel_session_get_service_connected (session, url_string, CAMEL_PROVIDER_STORE, ex))
#define camel_session_get_transport(session, url_string, ex) \ #define camel_session_get_transport(session, url_string, ex) \
((CamelTransport *) camel_session_get_service_connected (session, url_string, CAMEL_PROVIDER_TRANSPORT, ex)) ((CamelTransport *) camel_session_get_service_connected (session, url_string, CAMEL_PROVIDER_TRANSPORT, ex))
char * camel_session_get_storage_path (CamelSession *session, char * camel_session_get_storage_path (CamelSession *session,
CamelService *service, CamelService *service,
CamelException *ex); CamelException *ex);
gpointer camel_session_query_authenticator (CamelSession *session, char * camel_session_get_password (CamelSession *session,
CamelAuthCallbackMode mode, const char *prompt,
char *prompt, gboolean secret,
gboolean secret, CamelService *service,
CamelService *service, const char *item,
char *item, CamelException *ex);
CamelException *ex); void camel_session_forget_password (CamelSession *session,
CamelService *service,
const char *item,
CamelException *ex);
gboolean camel_session_alert_user (CamelSession *session,
CamelSessionAlertType type,
const char *prompt,
gboolean cancel);
guint camel_session_register_timeout (CamelSession *session, guint camel_session_register_timeout (CamelSession *session,
guint32 interval, guint32 interval,
CamelTimeoutCallback callback, CamelTimeoutCallback callback,
gpointer user_data); gpointer user_data);
gboolean camel_session_remove_timeout (CamelSession *session, gboolean camel_session_remove_timeout (CamelSession *session,
guint handle); guint handle);
#ifdef __cplusplus #ifdef __cplusplus
} }

5
camel/camel-smime-context.c
View File

@ -197,9 +197,8 @@ get_password (void *arg, SECKEYKeyDBHandle *handle)
return pwitem; return pwitem;
prompt = g_strdup_printf (_("Please enter your password for %s"), userid); prompt = g_strdup_printf (_("Please enter your password for %s"), userid);
passwd = camel_session_query_authenticator (session, CAMEL_AUTHENTICATOR_ASK, passwd = camel_session_get_password (session, prompt, TRUE,
prompt, TRUE, NULL, userid, NULL, userid, NULL);
NULL);
g_free (prompt); g_free (prompt);
/* hash the password */ /* hash the password */

8
camel/camel-tcp-stream-ssl.c
View File

@ -336,7 +336,7 @@ ssl_bad_cert (void *data, PRFileDesc *sockfd)
CERTCertificate *cert; CERTCertificate *cert;
CamelService *service; CamelService *service;
char *prompt, *cert_str; char *prompt, *cert_str;
gpointer accept; gboolean accept;
g_return_val_if_fail (data != NULL, SECFailure); g_return_val_if_fail (data != NULL, SECFailure);
g_return_val_if_fail (CAMEL_IS_SERVICE (data), SECFailure); g_return_val_if_fail (CAMEL_IS_SERVICE (data), SECFailure);
@ -366,12 +366,10 @@ ssl_bad_cert (void *data, PRFileDesc *sockfd)
g_free (cert_str); g_free (cert_str);
/* query the user to find out if we want to accept this certificate */ /* query the user to find out if we want to accept this certificate */
accept = camel_session_query_authenticator (service->session, CAMEL_AUTHENTICATOR_ACCEPT, accept = camel_session_alert_user (service->session, CAMEL_SESSION_ALERT_WARNING, prompt, TRUE, NULL);
prompt, FALSE, service, NULL, NULL);
g_free (prompt); g_free (prompt);
if (GPOINTER_TO_INT (accept)) if (accept)
return SECSuccess; return SECSuccess;
return SECFailure; return SECFailure;

11
camel/providers/imap/camel-imap-store.c
View File

@ -466,9 +466,8 @@ imap_auth_loop (CamelService *service, CamelException *ex)
while (!authenticated) { while (!authenticated) {
if (errbuf) { if (errbuf) {
/* We need to un-cache the password before prompting again */ /* We need to un-cache the password before prompting again */
camel_session_query_authenticator ( camel_session_forget_password (
session, CAMEL_AUTHENTICATOR_TELL, NULL, session, service, "password", ex);
TRUE, service, "password", ex);
g_free (service->url->passwd); g_free (service->url->passwd);
service->url->passwd = NULL; service->url->passwd = NULL;
} }
@ -482,9 +481,9 @@ imap_auth_loop (CamelService *service, CamelException *ex)
service->url->user, service->url->user,
service->url->host); service->url->host);
service->url->passwd = service->url->passwd =
camel_session_query_authenticator ( camel_session_get_password (
session, CAMEL_AUTHENTICATOR_ASK, session, prompt, TRUE,
prompt, TRUE, service, "password", ex); service, "password", ex);
g_free (prompt); g_free (prompt);
g_free (errbuf); g_free (errbuf);
errbuf = NULL; errbuf = NULL;

10
camel/providers/pop3/camel-pop3-store.c
View File

@ -369,10 +369,9 @@ pop3_try_authenticate (CamelService *service, gboolean kpop,
"for %s@%s"), errmsg ? errmsg : "", "for %s@%s"), errmsg ? errmsg : "",
service->url->user, service->url->user,
service->url->host); service->url->host);
service->url->passwd = camel_session_query_authenticator ( service->url->passwd = camel_session_get_password (
camel_service_get_session (service), camel_service_get_session (service),
CAMEL_AUTHENTICATOR_ASK, prompt, TRUE, prompt, TRUE, service, "password", ex);
service, "password", ex);
g_free (prompt); g_free (prompt);
if (!service->url->passwd) if (!service->url->passwd)
return FALSE; return FALSE;
@ -449,10 +448,9 @@ pop3_connect (CamelService *service, CamelException *ex)
camel_exception_clear (ex); camel_exception_clear (ex);
/* Uncache the password before prompting again. */ /* Uncache the password before prompting again. */
camel_session_query_authenticator ( camel_session_forget_password (
camel_service_get_session (service), camel_service_get_session (service),
CAMEL_AUTHENTICATOR_TELL, NULL, TRUE, service, service, "password", ex);
"password", ex);
g_free (service->url->passwd); g_free (service->url->passwd);
service->url->passwd = NULL; service->url->passwd = NULL;
} }

11
camel/providers/smtp/camel-smtp-transport.c
View File

@ -375,9 +375,8 @@ smtp_connect (CamelService *service, CamelException *ex)
while (!authenticated) { while (!authenticated) {
if (errbuf) { if (errbuf) {
/* We need to un-cache the password before prompting again */ /* We need to un-cache the password before prompting again */
camel_session_query_authenticator ( camel_session_forget_password (
session, CAMEL_AUTHENTICATOR_TELL, NULL, session, service, "password", ex);
TRUE, service, "password", ex);
g_free (service->url->passwd); g_free (service->url->passwd);
service->url->passwd = NULL; service->url->passwd = NULL;
} }
@ -390,9 +389,9 @@ smtp_connect (CamelService *service, CamelException *ex)
service->url->host); service->url->host);
service->url->passwd = service->url->passwd =
camel_session_query_authenticator ( camel_session_get_password (
session, CAMEL_AUTHENTICATOR_ASK, session, prompt, TRUE,
prompt, TRUE, service, "password", ex); service, "password", ex);
g_free (prompt); g_free (prompt);
g_free (errbuf); g_free (errbuf);