ESource *
em_utils_ref_mail_identity_for_store (ESourceRegistry *registry,
CamelStore *store)
{
ESourceMailAccount *extension;
ESource *source;
const gchar *extension_name;
const gchar *store_uid;
gchar *identity_uid;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
store_uid = camel_service_get_uid (CAMEL_SERVICE (store));
g_return_val_if_fail (store_uid != NULL, NULL);
source = e_source_registry_ref_source (registry, store_uid);
g_return_val_if_fail (source != NULL, NULL);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (source, extension_name);
identity_uid = e_source_mail_account_dup_identity_uid (extension);
g_object_unref (source);
source = NULL;
if (identity_uid != NULL) {
source = e_source_registry_ref_source (registry, identity_uid);
g_free (identity_uid);
}
return source;
}
/* Helper for e_mail_session_ref_transport_for_message() */
static CamelService *
mail_session_ref_transport_from_x_identity (EMailSession *session,
CamelMimeMessage *message)
{
ESource *source;
ESourceRegistry *registry;
CamelMedium *medium;
CamelService *transport;
const gchar *header_name;
const gchar *header_value;
gchar *uid;
medium = CAMEL_MEDIUM (message);
header_name = "X-Evolution-Identity";
header_value = camel_medium_get_header (medium, header_name);
if (header_value == NULL)
return NULL;
uid = g_strstrip (g_strdup (header_value));
registry = e_mail_session_get_registry (session);
source = e_source_registry_ref_source (registry, uid);
transport = mail_session_ref_transport_for_identity (session, source);
g_clear_object (&source);
g_free (uid);
return transport;
}
static ESource *
guess_mail_account_from_message (ESourceRegistry *registry,
CamelMimeMessage *message)
{
ESource *source = NULL;
const gchar *uid;
/* Lookup an ESource by 'X-Evolution-Source' header. */
uid = camel_mime_message_get_source (message);
if (uid != NULL)
source = e_source_registry_ref_source (registry, uid);
/* If we found an ESource, make sure it's a mail account. */
if (source != NULL) {
const gchar *extension_name;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
source = NULL;
}
}
return source;
}
static void
e_mail_config_mapi_extension_constructed (GObject *object)
{
EExtension *extension;
EExtensible *extensible;
ESource *source;
ESourceBackend *backend_ext;
EMailConfigNotebook *notebook;
const gchar *backend_name;
const gchar *extension_name;
extension = E_EXTENSION (object);
extensible = e_extension_get_extensible (extension);
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_mail_config_mapi_extension_parent_class)->constructed (object);
notebook = E_MAIL_CONFIG_NOTEBOOK (extensible);
source = e_mail_config_notebook_get_account_source (notebook);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
backend_ext = e_source_get_extension (source, extension_name);
backend_name = e_source_backend_get_backend_name (backend_ext);
if (g_strcmp0 (backend_name, "mapi") == 0) {
ESource *profile_source;
ESourceCamel *camel_ext;
ESourceRegistry *registry;
EMailSession *mail_session;
CamelSettings *settings;
const gchar *profile;
mail_session = e_mail_config_notebook_get_session (notebook);
registry = e_mail_session_get_registry (mail_session);
if (e_source_get_parent (source))
profile_source = e_source_registry_ref_source (registry, e_source_get_parent (source));
else
profile_source = g_object_ref (source);
camel_ext = e_source_get_extension (profile_source, e_source_camel_get_extension_name (backend_name));
settings = e_source_camel_get_settings (camel_ext);
profile = camel_mapi_settings_get_profile (CAMEL_MAPI_SETTINGS (settings));
/* add page only when editing already configured accounts */
if (profile && *profile) {
EMailConfigPage *page;
page = e_mail_config_mapi_page_new (source, registry);
e_mail_config_notebook_add_page (notebook, page);
}
g_object_unref (profile_source);
}
}
gboolean
eab_source_and_contact_list_from_string (ESourceRegistry *registry,
const gchar *str,
ESource **out_source,
GSList **out_contacts)
{
ESource *source;
const gchar *s0, *s1;
gchar *uid;
gboolean success = FALSE;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), FALSE);
g_return_val_if_fail (str != NULL, FALSE);
if (out_source != NULL)
*out_source = NULL; /* in case we fail */
if (out_contacts != NULL)
*out_contacts = NULL; /* in case we fail */
if (!strncmp (str, "Book: ", 6)) {
s0 = str + 6;
s1 = strchr (str, '\r');
if (!s1)
s1 = strchr (str, '\n');
} else {
s0 = NULL;
s1 = NULL;
}
if (!s0 || !s1)
return FALSE;
uid = g_strndup (s0, s1 - s0);
source = e_source_registry_ref_source (registry, uid);
if (source != NULL) {
if (out_source != NULL)
*out_source = g_object_ref (source);
g_object_unref (source);
success = TRUE;
}
g_free (uid);
if (success && out_contacts != NULL)
*out_contacts = eab_contact_list_from_string (str);
return success;
}
static gboolean
mail_account_in_recipients (ESourceRegistry *registry,
ESource *source,
GHashTable *recipients)
{
ESourceExtension *extension;
const gchar *extension_name;
const gchar *uid;
gboolean match = FALSE;
gchar *address;
/* Disregard disabled mail accounts. */
if (!e_source_registry_check_enabled (registry, source))
return FALSE;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (source, extension_name);
uid = e_source_mail_account_get_identity_uid (
E_SOURCE_MAIL_ACCOUNT (extension));
if (uid == NULL)
return FALSE;
source = e_source_registry_ref_source (registry, uid);
if (source == NULL)
return FALSE;
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
return FALSE;
}
extension = e_source_get_extension (source, extension_name);
address = e_source_mail_identity_dup_address (
E_SOURCE_MAIL_IDENTITY (extension));
g_object_unref (source);
if (address != NULL) {
match = g_hash_table_contains (recipients, address);
g_free (address);
}
return match;
}
gint
main (gint argc,
gchar **argv)
{
ESourceRegistry *registry;
ESource *source = NULL;
GtkWidget *config;
GtkWidget *dialog;
GError *error = NULL;
gtk_init (&argc, &argv);
registry = e_source_registry_new_sync (NULL, &error);
if (error != NULL) {
g_printerr ("%s\n", error->message);
exit (EXIT_FAILURE);
}
if (argc > 1) {
source = e_source_registry_ref_source (registry, argv[1]);
if (source == NULL) {
g_printerr ("No such UID: %s\n", argv[1]);
exit (EXIT_FAILURE);
}
}
config = e_source_config_new (registry, source);
dialog = e_source_config_dialog_new (E_SOURCE_CONFIG (config));
g_signal_connect (
dialog, "response",
G_CALLBACK (dialog_response), NULL);
gtk_widget_show (config);
gtk_widget_show (dialog);
g_object_unref (source);
gtk_main ();
e_util_cleanup_settings ();
return 0;
}
ESource *
em_utils_guess_mail_identity (ESourceRegistry *registry,
CamelMimeMessage *message,
CamelFolder *folder,
const gchar *message_uid)
{
ESource *source;
ESourceExtension *extension;
const gchar *extension_name;
const gchar *uid;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
if (folder != NULL)
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
source = em_utils_guess_mail_account (registry, message, folder, message_uid);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (source, extension_name);
uid = e_source_mail_account_get_identity_uid (
E_SOURCE_MAIL_ACCOUNT (extension));
if (uid == NULL)
return NULL;
source = e_source_registry_ref_source (registry, uid);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
return NULL;
}
return source;
}
ESource *
em_utils_guess_mail_identity_with_recipients_and_sort (ESourceRegistry *registry,
CamelMimeMessage *message,
CamelFolder *folder,
const gchar *message_uid,
EMailUtilsSourtSourcesFunc sort_func,
gpointer sort_func_data)
{
ESource *source;
ESourceExtension *extension;
const gchar *extension_name;
const gchar *uid;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
source = em_utils_guess_mail_account_with_recipients_and_sort (
registry, message, folder, message_uid, sort_func, sort_func_data);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (source, extension_name);
uid = e_source_mail_account_get_identity_uid (
E_SOURCE_MAIL_ACCOUNT (extension));
if (uid == NULL)
return NULL;
source = e_source_registry_ref_source (registry, uid);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
return NULL;
}
return source;
}
static CamelService *
ref_default_transport (EMailSession *session)
{
ESource *source;
CamelService *service;
const gchar *extension_name;
const gchar *uid;
source = e_source_registry_ref_default_mail_identity (source_registry);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;
if (e_source_has_extension (source, extension_name)) {
ESourceMailSubmission *extension;
gchar *uid;
extension = e_source_get_extension (source, extension_name);
uid = e_source_mail_submission_dup_transport_uid (extension);
g_object_unref (source);
source = e_source_registry_ref_source (source_registry, uid);
g_free (uid);
} else {
g_object_unref (source);
source = NULL;
}
if (source == NULL)
return NULL;
uid = e_source_get_uid (source);
service = camel_session_ref_service (CAMEL_SESSION (session), uid);
g_object_unref (source);
return service;
}
static ESource *
guess_mail_account_from_folder (ESourceRegistry *registry,
CamelFolder *folder,
const gchar *message_uid)
{
ESource *source;
CamelStore *store;
const gchar *uid;
/* Lookup an ESource by CamelStore UID. */
store = camel_folder_get_parent_store (folder);
if (message_uid && folder && CAMEL_IS_VEE_STORE (store)) {
CamelMessageInfo *mi = camel_folder_get_message_info (folder, message_uid);
if (mi) {
CamelFolder *location;
location = camel_vee_folder_get_location (CAMEL_VEE_FOLDER (folder), (CamelVeeMessageInfo *) mi, NULL);
if (location)
store = camel_folder_get_parent_store (location);
camel_folder_free_message_info (folder, mi);
}
}
uid = camel_service_get_uid (CAMEL_SERVICE (store));
source = e_source_registry_ref_source (registry, uid);
/* If we found an ESource, make sure it's a mail account. */
if (source != NULL) {
const gchar *extension_name;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
source = NULL;
}
}
return source;
}
/**
* e_mail_session_ref_transport:
* @session: an #EMailSession
* @transport_uid: the UID of a mail transport
*
* Returns the transport #CamelService instance for @transport_uid,
* verifying first that the @transport_uid is indeed a mail transport and
* that the corresponding #ESource is enabled. If these checks fail, the
* function returns %NULL.
*
* The returned #CamelService is referenced for thread-safety and must be
* unreferenced with g_object_unref() when finished with it.
*
* Returns: a #CamelService, or %NULL
**/
CamelService *
e_mail_session_ref_transport (EMailSession *session,
const gchar *transport_uid)
{
ESourceRegistry *registry;
ESource *source = NULL;
CamelService *transport = NULL;
const gchar *extension_name;
g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
g_return_val_if_fail (transport_uid != NULL, NULL);
registry = e_mail_session_get_registry (session);
extension_name = E_SOURCE_EXTENSION_MAIL_TRANSPORT;
source = e_source_registry_ref_source (registry, transport_uid);
if (source == NULL)
goto exit;
if (!e_source_registry_check_enabled (registry, source))
goto exit;
if (!e_source_has_extension (source, extension_name))
goto exit;
transport = camel_session_ref_service (
CAMEL_SESSION (session), transport_uid);
/* Sanity check. */
if (transport != NULL)
g_warn_if_fail (CAMEL_IS_TRANSPORT (transport));
exit:
g_clear_object (&source);
return transport;
}
/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_fcc_from_x_identity (EMailSession *session,
CamelMimeMessage *message,
GCancellable *cancellable,
GError **error)
{
ESource *source;
ESourceRegistry *registry;
CamelFolder *folder;
CamelMedium *medium;
const gchar *header_name;
const gchar *header_value;
gchar *uid;
medium = CAMEL_MEDIUM (message);
header_name = "X-Evolution-Identity";
header_value = camel_medium_get_header (medium, header_name);
if (header_value == NULL)
return NULL;
uid = g_strstrip (g_strdup (header_value));
registry = e_mail_session_get_registry (session);
source = e_source_registry_ref_source (registry, uid);
/* This may return NULL without setting a GError. */
folder = mail_session_ref_fcc_from_identity (
session, source, message, cancellable, error);
g_clear_object (&source);
g_free (uid);
return folder;
}
static gboolean
write_calendar (const gchar *uid,
GOutputStream *stream,
gint dur_type,
gint dur_value,
GError **error)
{
EShell *shell;
ESource *source;
ESourceRegistry *registry;
EClient *client = NULL;
GSList *objects = NULL;
icaltimezone *utc;
time_t start = time (NULL), end;
icalcomponent *top_level;
gchar *email = NULL;
GSList *users = NULL;
gulong handler_id;
gboolean success = FALSE;
utc = icaltimezone_get_utc_timezone ();
start = time_day_begin_with_zone (start, utc);
switch (dur_type) {
case FB_DURATION_DAYS:
end = time_add_day_with_zone (start, dur_value, utc);
break;
default:
case FB_DURATION_WEEKS:
end = time_add_week_with_zone (start, dur_value, utc);
break;
case FB_DURATION_MONTHS:
end = time_add_month_with_zone (start, dur_value, utc);
break;
}
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
source = e_source_registry_ref_source (registry, uid);
if (source != NULL) {
EClientCache *client_cache;
client_cache = e_shell_get_client_cache (shell);
client = e_client_cache_get_client_sync (client_cache, source, E_SOURCE_EXTENSION_CALENDAR, 30, NULL, error);
g_object_unref (source);
} else {
g_set_error (
error, E_CAL_CLIENT_ERROR,
E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR,
_("Invalid source UID '%s'"), uid);
}
if (client == NULL)
return FALSE;
if (e_client_get_backend_property_sync (client, CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS, &email, NULL, NULL)) {
if (email && *email)
users = g_slist_append (users, email);
}
top_level = e_cal_util_new_top_level ();
handler_id = g_signal_connect (
client, "free-busy-data",
G_CALLBACK (free_busy_data_cb), &objects);
success = e_cal_client_get_free_busy_sync (
E_CAL_CLIENT (client), start, end, users, NULL, error);
if (handler_id > 0)
g_signal_handler_disconnect (client, handler_id);
if (success) {
gchar *ical_string;
GSList *iter;
gboolean done = FALSE;
/* This is to workaround broken dispatch of "free-busy-data" signal,
* introduced in 3.8.0. This code can be removed once the below bug is
* properly fixed: https://bugzilla.gnome.org/show_bug.cgi?id=692361
*/
while (!done) {
g_usleep (G_USEC_PER_SEC / 10);
done = !g_main_context_iteration (NULL, FALSE);
}
for (iter = objects; iter; iter = iter->next) {
ECalComponent *comp = iter->data;
icalcomponent *icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp));
icalcomponent_add_component (top_level, icalcomp);
}
ical_string = icalcomponent_as_ical_string_r (top_level);
success = g_output_stream_write_all (
stream, ical_string,
strlen (ical_string),
NULL, NULL, error);
e_cal_client_free_ecalcomp_slist (objects);
g_free (ical_string);
}
if (users)
g_slist_free (users);
g_free (email);
g_object_unref (client);
icalcomponent_free (top_level);
return success;
}
static gboolean
write_calendar (const gchar *uid,
GOutputStream *stream,
gint dur_type,
gint dur_value,
GError **error)
{
EShell *shell;
ESource *source;
ESourceRegistry *registry;
EClient *client = NULL;
GSList *objects = NULL;
icaltimezone *utc;
time_t start = time (NULL), end;
icalcomponent *top_level;
gchar *email = NULL;
GSList *users = NULL;
gboolean success = FALSE;
utc = icaltimezone_get_utc_timezone ();
start = time_day_begin_with_zone (start, utc);
switch (dur_type) {
case FB_DURATION_DAYS:
end = time_add_day_with_zone (start, dur_value, utc);
break;
default:
case FB_DURATION_WEEKS:
end = time_add_week_with_zone (start, dur_value, utc);
break;
case FB_DURATION_MONTHS:
end = time_add_month_with_zone (start, dur_value, utc);
break;
}
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
source = e_source_registry_ref_source (registry, uid);
if (source != NULL) {
EClientCache *client_cache;
client_cache = e_shell_get_client_cache (shell);
client = e_client_cache_get_client_sync (client_cache, source, E_SOURCE_EXTENSION_CALENDAR, 30, NULL, error);
g_object_unref (source);
} else {
g_set_error (
error, E_CAL_CLIENT_ERROR,
E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR,
_("Invalid source UID “%s”"), uid);
}
if (client == NULL)
return FALSE;
if (e_client_get_backend_property_sync (client, CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS, &email, NULL, NULL)) {
if (email && *email)
users = g_slist_append (users, email);
}
top_level = e_cal_util_new_top_level ();
success = e_cal_client_get_free_busy_sync (
E_CAL_CLIENT (client), start, end, users, &objects, NULL, error);
if (success) {
gchar *ical_string;
GSList *iter;
for (iter = objects; iter; iter = iter->next) {
ECalComponent *comp = iter->data;
icalcomponent *icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp));
icalcomponent_add_component (top_level, icalcomp);
}
ical_string = icalcomponent_as_ical_string_r (top_level);
success = g_output_stream_write_all (
stream, ical_string,
strlen (ical_string),
NULL, NULL, error);
e_cal_client_free_ecalcomp_slist (objects);
g_free (ical_string);
}
if (users)
g_slist_free (users);
g_free (email);
g_object_unref (client);
icalcomponent_free (top_level);
return success;
}
static gboolean
ews_transport_can_server_side_sent_folder (CamelService *service,
EwsFolderId **folder_id,
GCancellable *cancellable)
{
CamelSession *session;
ESourceRegistry *registry;
ESource *sibling, *source = NULL;
gboolean is_server_side = FALSE;
g_return_val_if_fail (CAMEL_IS_EWS_TRANSPORT (service), FALSE);
g_return_val_if_fail (folder_id != NULL, FALSE);
session = camel_service_ref_session (service);
if (session && E_IS_MAIL_SESSION (session))
registry = g_object_ref (e_mail_session_get_registry (E_MAIL_SESSION (session)));
else
registry = e_source_registry_new_sync (cancellable, NULL);
if (!registry) {
g_clear_object (&session);
return FALSE;
}
sibling = e_source_registry_ref_source (registry, camel_service_get_uid (service));
if (sibling) {
GList *sources, *siter;
sources = e_source_registry_list_sources (registry, E_SOURCE_EXTENSION_MAIL_SUBMISSION);
for (siter = sources; siter; siter = siter->next) {
source = siter->data;
if (!source || g_strcmp0 (e_source_get_parent (source), e_source_get_parent (sibling)) != 0 ||
!e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION) ||
!e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_COMPOSITION))
source = NULL;
else
break;
}
if (source &&
e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION) &&
e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_COMPOSITION)) {
ESourceMailSubmission *subm_extension;
CamelStore *store = NULL;
gchar *folder_name = NULL;
subm_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION);
/* Copy messages on the server side only if the replies
might not be saved to the original folder, which is handled
by the evolution itself. */
if (!e_source_mail_submission_get_replies_to_origin_folder (subm_extension) &&
e_source_mail_submission_get_sent_folder (subm_extension) &&
e_mail_folder_uri_parse (session,
e_source_mail_submission_get_sent_folder (subm_extension),
&store, &folder_name, NULL) & CAMEL_IS_EWS_STORE (store)) {
CamelEwsStore *ews_store = CAMEL_EWS_STORE (store);
gchar *folder_id_str;
folder_id_str = camel_ews_store_summary_get_folder_id_from_name (
ews_store->summary, folder_name);
if (folder_id_str) {
gchar *change_key;
change_key = camel_ews_store_summary_get_change_key (ews_store->summary, folder_name, NULL);
*folder_id = e_ews_folder_id_new (folder_id_str, change_key, FALSE);
g_free (change_key);
is_server_side = *folder_id != NULL;
}
g_free (folder_id_str);
}
g_clear_object (&store);
g_free (folder_name);
}
g_list_free_full (sources, g_object_unref);
g_object_unref (sibling);
}
g_object_unref (registry);
g_clear_object (&session);
return is_server_side;
}
GCancellable *
mail_send (EMailSession *session)
{
CamelFolder *local_outbox;
CamelService *service;
struct _send_info *info;
struct _send_data *data;
send_info_t type = SEND_INVALID;
const gchar *transport_uid;
ESource *account;
const gchar *extension_name;
account = e_source_registry_ref_default_mail_identity (source_registry);
if (account == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;
if (e_source_has_extension (account, extension_name)) {
ESourceMailSubmission *extension;
gchar *uid;
extension = e_source_get_extension (account, extension_name);
uid = e_source_mail_submission_dup_transport_uid (extension);
g_object_unref (account);
account = e_source_registry_ref_source (source_registry, uid);
g_free (uid);
} else {
g_object_unref (account);
account = NULL;
}
if (account == NULL)
return NULL;
transport_uid = e_source_get_uid (account);
data = setup_send_data (session);
info = g_hash_table_lookup (data->active, SEND_URI_KEY);
if (info != NULL) {
info->again++;
d(printf("send of %s still in progress\n", transport_uid));
return info->cancellable;
}
service = camel_session_ref_service (
CAMEL_SESSION (session), transport_uid);
if (!CAMEL_IS_TRANSPORT (service)) {
return NULL;
}
d(printf("starting non-interactive send of '%s'\n", account->transport->url));
type = get_receive_type (service);
if (type == SEND_INVALID) {
return NULL;
}
info = g_malloc0 (sizeof (*info));
info->type = SEND_SEND;
info->session = g_object_ref (session);
info->service = g_object_ref (service);
info->keep_on_server = FALSE;
info->cancellable = camel_operation_new();
info->data = data;
info->state = SEND_ACTIVE;
info->timeout_id = 0;
d(printf("Adding new info %p\n", info));
g_hash_table_insert (data->active, g_strdup(SEND_URI_KEY), info);
/* todo, store the folder in info? */
local_outbox =
e_mail_session_get_local_folder (
session, E_MAIL_LOCAL_FOLDER_OUTBOX);
mail_send_queue (
session, local_outbox,
CAMEL_TRANSPORT (service),
E_FILTER_SOURCE_OUTGOING,
info->cancellable,
receive_get_folder, info,
receive_status, info,
send_done, info);
return info->cancellable;
}
/* Entry point for this file, here we take care of
* creating the addressbook if it doesnt exist,
* getting an EBookClient, and creating our EBookClientCursor.
*/
EBookClient *
cursor_load_data (const gchar *vcard_path,
EBookClientCursor **ret_cursor)
{
ESourceRegistry *registry;
ESource *scratch;
ESourceBackend *backend = NULL;
GMainLoop *loop;
GError *error = NULL;
EBookClient *ret_book;
g_return_val_if_fail (vcard_path != NULL, NULL);
g_return_val_if_fail (ret_cursor != NULL, NULL);
g_print ("Cursor loading data from %s\n", vcard_path);
loop = g_main_loop_new (NULL, FALSE);
registry = e_source_registry_new_sync (NULL, &error);
if (!registry)
g_error ("Unable to create the registry: %s", error->message);
/* Listen to the registry for our added source */
g_signal_connect (
registry, "source-added",
G_CALLBACK (cursor_data_source_added), loop);
/* Now create a scratch source for our addressbook */
scratch = e_source_new_with_uid (CURSOR_DATA_SOURCE_ID, NULL, &error);
/* Ensure the new ESource will be a local addressbook source */
backend = e_source_get_extension (scratch, E_SOURCE_EXTENSION_ADDRESS_BOOK);
e_source_backend_set_backend_name (backend, "local");
/* Now is the right time to use the ESourceBackendSummarySetup to configure
* your newly created addressbook. This configuration should happen on the
* scratch source before calling e_source_registry_commit_source_sync().
*/
/* Commit the source to the registry */
if (!e_source_registry_commit_source_sync (registry, scratch, NULL, &error)) {
/* It's possible the source already exists if we already ran the example with this data server */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
/* If so... then just call our callback early */
ESource *source = e_source_registry_ref_source (registry, CURSOR_DATA_SOURCE_ID);
g_clear_error (&error);
g_return_val_if_fail (E_IS_SOURCE (source), NULL);
/* Run the callback which creates the addressbook client connection */
cursor_data_source_added (registry, source, NULL);
g_object_unref (source);
} else
g_error ("Unable to add new addressbook source to the registry: %s", error->message);
}
g_object_unref (scratch);
/* Give EDS a little time to actually create the ESource remotely and
* also have a copy if it cached locally, wait for the "source-added"
* signal.
*/
if (address_book == NULL) {
g_timeout_add_seconds (20, cursor_data_source_timeout, NULL);
g_main_loop_run (loop);
/* By now we aborted or we have an addressbook created */
g_return_val_if_fail (address_book != NULL, NULL);
}
/**********************************************************
* Ok, done with creating an addressbook, let's add data *
**********************************************************/
load_contacts (address_book, vcard_path);
/* Addressbook should have contacts now, let's create the cursor */
*ret_cursor = get_cursor (address_book);
/* Cleanup some resources we used to populate the addressbook */
g_main_loop_unref (loop);
g_object_unref (address_book_source);
g_object_unref (registry);
/* Give the ref through the return value*/
ret_book = address_book;
address_book_source = NULL;
address_book = NULL;
/* Return the addressbook */
return ret_book;
}
/**
* e_cal_backend_mail_account_is_valid:
* @registry: an #ESourceRegistry
* @user: user name for the account to check
* @name: placeholder for the account name
*
* Checks that a mail account is valid, and returns its name.
*
* Returns: TRUE if the account is valid, FALSE if not.
*/
gboolean
e_cal_backend_mail_account_is_valid (ESourceRegistry *registry,
gchar *user,
gchar **name)
{
GList *list, *iter;
const gchar *extension_name;
gboolean valid = FALSE;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), FALSE);
g_return_val_if_fail (user != NULL, FALSE);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
list = e_source_registry_list_enabled (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceMailAccount *mail_account;
ESourceMailIdentity *mail_identity;
const gchar *uid;
gboolean match = FALSE;
gchar *address;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
mail_account = e_source_get_extension (source, extension_name);
uid = e_source_mail_account_get_identity_uid (mail_account);
if (uid == NULL)
continue;
source = e_source_registry_ref_source (registry, uid);
if (source == NULL)
continue;
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
continue;
}
mail_identity = e_source_get_extension (source, extension_name);
address = e_source_mail_identity_dup_address (mail_identity);
if (address != NULL) {
match = (g_ascii_strcasecmp (address, user) == 0);
g_free (address);
}
if (match && name != NULL)
*name = e_source_dup_display_name (source);
g_object_unref (source);
if (match) {
valid = TRUE;
break;
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
return valid;
}
enum OpenAB_Storage::Storage::eInit EDSCalendarStorage::init()
{
LOG_FUNC() << "DB: " << database<<std::endl;
GError *gerror = NULL;
// 1. Get access to all databases in EDS.
registry = e_source_registry_new_sync(NULL, &gerror);
if (!registry)
{
LOG_ERROR() << "e_source_registry not found " << GERROR_MESSAGE(gerror)<<std::endl;
GERROR_FREE(gerror);
return eInitFail;
}
// 2. Look up one particular database.
// special use case - "system" db - use system storage
std::string dbName = database;
if (dbName == "system")
{
if (OpenAB::eEvent == getItemType())
{
source = e_source_registry_ref_default_calendar(registry);
}
else if (OpenAB::eTask == getItemType())
{
source = e_source_registry_ref_default_task_list(registry);
}
}
else
{
source = e_source_registry_ref_source(registry, dbName.c_str());
}
if (!source)
{
LOG_ERROR() << "e_source not found"<<std::endl;
GERROR_FREE(gerror);
return eInitFail;
}
GERROR_FREE(gerror);
const gchar *userDataDir = NULL;
userDataDir = e_get_user_data_dir();
gchar* dirname = NULL;
if (OpenAB::eEvent == getItemType())
{
client = (ECalClient *) e_cal_client_connect_sync(source, E_CAL_CLIENT_SOURCE_TYPE_EVENTS, NULL, &gerror);
dirname = g_build_filename(userDataDir, "calendar", dbName.c_str(), "calendar.ics", NULL);
}
else
{
client = (ECalClient *) e_cal_client_connect_sync(source, E_CAL_CLIENT_SOURCE_TYPE_TASKS, NULL, &gerror);
dirname = g_build_filename(userDataDir, "tasks", dbName.c_str(), "tasks.ics", NULL);
}
databaseFileName = dirname;
g_free(dirname);
if (gerror)
{
LOG_ERROR() << "Error e_cal_client_connect_sync results: " << GERROR_MESSAGE(gerror)<<std::endl;
GERROR_FREE(gerror);
return eInitFail;
}
LOG_VERBOSE() << "e_cal_client_connect_sync\n"<<std::endl;
return eInitOk;
}
