GNOME Documentation Library

struct CamelSession

struct CamelSession {
	CamelObject parent_object;
	struct _CamelSessionPrivate *priv;

	gchar *storage_path;
	CamelJunkPlugin *junk_plugin;

	guint online:1;
	guint check_junk:1;
	guint network_state:1;
};

CamelTimeoutCallback ()

gboolean            (*CamelTimeoutCallback)             (gpointer data);

enum CamelSessionAlertType

typedef enum {
	CAMEL_SESSION_ALERT_INFO,
	CAMEL_SESSION_ALERT_WARNING,
	CAMEL_SESSION_ALERT_ERROR
} CamelSessionAlertType;

CamelSessionThreadOps

typedef struct {
	void (*receive)(CamelSession *session, struct _CamelSessionThreadMsg *m);
	void (*free)(CamelSession *session, struct _CamelSessionThreadMsg *m);
} CamelSessionThreadOps;

CamelSessionThreadMsg

typedef struct {
	CamelMsg msg;

	gint id;

	CamelException ex;
	CamelSessionThreadOps *ops;
	struct _CamelOperation *op;
	CamelSession *session;

	gpointer data; /* free for implementation to define, not used by camel, do not use in client code */
	/* user fields follow */
} CamelSessionThreadMsg;

camel_session_construct ()

void                camel_session_construct             (CamelSession *session,
                                                         const gchar *storage_path);

Constructs session.

camel_session_get_service ()

CamelService *      camel_session_get_service           (CamelSession *session,
                                                         const gchar *url_string,
                                                         CamelProviderType type,
                                                         CamelException *ex);

This resolves a CamelURL into a CamelService, including loading the provider library for that service if it has not already been loaded.

Services are cached, and asking for "the same" url_string multiple times will return the same CamelService (with its reference count incremented by one each time). What constitutes "the same" URL depends in part on the provider.

camel_session_get_service_connected ()

CamelService *      camel_session_get_service_connected (CamelSession *session,
                                                         const gchar *url_string,
                                                         CamelProviderType type,
                                                         CamelException *ex);

This works like camel_session_get_service, but also ensures that the returned service will have been successfully connected (via camel_service_connect.)

camel_session_get_store()

#define             camel_session_get_store(session, url_string, ex)

camel_session_get_transport()

#define             camel_session_get_transport(session, url_string, ex)

camel_session_get_storage_path ()

gchar *             camel_session_get_storage_path      (CamelSession *session,
                                                         CamelService *service,
                                                         CamelException *ex);

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.

camel_session_get_password ()

gchar *             camel_session_get_password          (CamelSession *session,
                                                         CamelService *service,
                                                         const gchar *domain,
                                                         const gchar *prompt,
                                                         const gchar *item,
                                                         guint32 flags,
                                                         CamelException *ex);

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 CAMEL_SESSION_PASSWORD_SECRET is set, the user's input will not be echoed back.

If CAMEL_SESSION_PASSWORD_STATIC is set, it means the password returned will be stored statically by the caller automatically, for the current session.

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.

camel_session_forget_password ()

void                camel_session_forget_password       (CamelSession *session,
                                                         CamelService *service,
                                                         const gchar *domain,
                                                         const gchar *item,
                                                         CamelException *ex);

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.

camel_session_alert_user ()

gboolean            camel_session_alert_user            (CamelSession *session,
                                                         CamelSessionAlertType type,
                                                         const gchar *prompt,
                                                         gboolean cancel);

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.

camel_session_build_password_prompt ()

gchar *             camel_session_build_password_prompt (const gchar *type,
                                                         const gchar *user,
                                                         const gchar *host);

Constructs a localized password prompt from type, user and host, suitable for passing to camel_session_get_password(). The resulting string contains markup tags. Use g_free() to free it.

camel_session_is_online ()

gboolean            camel_session_is_online             (CamelSession *session);

camel_session_set_online ()

void                camel_session_set_online            (CamelSession *session,
                                                         gboolean online);

Sets the online status of session to online.

camel_session_get_filter_driver ()

CamelFilterDriver * camel_session_get_filter_driver     (CamelSession *session,
                                                         const gchar *type,
                                                         CamelException *ex);

camel_session_check_junk ()

gboolean            camel_session_check_junk            (CamelSession *session);

Do we have to check incoming messages to be junk?

camel_session_set_check_junk ()

void                camel_session_set_check_junk        (CamelSession *session,
                                                         gboolean check_junk);

Set check_junk flag, if set, incoming mail will be checked for being junk.

camel_session_thread_msg_new ()

gpointer            camel_session_thread_msg_new        (CamelSession *session,
                                                         CamelSessionThreadOps *ops,
                                                         guint size);

Create a new thread message, using ops as the receive/reply/free ops, of size bytes.

ops points to the operations used to recieve/process and finally free the message.

camel_session_thread_msg_free ()

void                camel_session_thread_msg_free       (CamelSession *session,
                                                         CamelSessionThreadMsg *msg);

Free a msg. Note that the message must have been allocated using msg_new, and must nto have been submitted to any queue function.

camel_session_thread_queue ()

gint                camel_session_thread_queue          (CamelSession *session,
                                                         CamelSessionThreadMsg *msg,
                                                         gint flags);

Queue a thread message in another thread for processing. The operation should be (but needn't) run in a queued manner with other operations queued in this manner.

camel_session_thread_wait ()

void                camel_session_thread_wait           (CamelSession *session,
                                                         gint id);

Wait on an operation to complete (by id).

camel_session_get_network_state ()

gboolean            camel_session_get_network_state     (CamelSession *session);

camel_session_set_network_state ()

void                camel_session_set_network_state     (CamelSession *session,
                                                         gboolean network_state);

camel_session_get_junk_headers ()

const GHashTable *  camel_session_get_junk_headers      (CamelSession *session);

camel_session_set_junk_headers ()

void                camel_session_set_junk_headers      (CamelSession *session,
                                                         const gchar **headers,
                                                         const gchar **values,
                                                         gint len);

camel_session_lookup_addressbook ()

gboolean            camel_session_lookup_addressbook    (CamelSession *session,
                                                         const gchar *name);

camel_session_forward_to ()

void                camel_session_forward_to            (CamelSession *session,
                                                         struct _CamelFolder *folder,
                                                         struct _CamelMimeMessage *message,
                                                         const gchar *address,
                                                         CamelException *ex);