static void
mc_setup_local_store(MailComponent *mc)
{
MailComponentPrivate *p = mc->priv;
CamelURL *url;
char *tmp;
CamelException ex;
int i;
g_mutex_lock(p->lock);
if (p->local_store != NULL) {
g_mutex_unlock(p->lock);
return;
}
camel_exception_init(&ex);
url = camel_url_new("mbox:", NULL);
tmp = g_build_filename (p->base_directory, "local", NULL);
camel_url_set_path(url, tmp);
g_free(tmp);
tmp = camel_url_to_string(url, 0);
p->local_store = (CamelStore *)camel_session_get_service(session, tmp, CAMEL_PROVIDER_STORE, &ex);
g_free(tmp);
if (p->local_store == NULL)
goto fail;
for (i=0;i<sizeof(mc_default_folders)/sizeof(mc_default_folders[0]);i++) {
/* FIXME: should this uri be account relative? */
camel_url_set_fragment(url, mc_default_folders[i].name);
mc_default_folders[i].uri = camel_url_to_string(url, 0);
mc_default_folders[i].folder = camel_store_get_folder(p->local_store, mc_default_folders[i].name,
CAMEL_STORE_FOLDER_CREATE, &ex);
camel_exception_clear(&ex);
}
camel_url_free(url);
g_mutex_unlock(p->lock);
g_object_ref(mc);
camel_object_ref(p->local_store);
mail_async_event_emit(p->async_event, MAIL_ASYNC_GUI, (MailAsyncFunc)mc_add_local_store, p->local_store, _("On This Computer"), mc);
return;
fail:
g_mutex_unlock(p->lock);
g_warning("Could not setup local store/folder: %s", ex.desc);
camel_url_free(url);
camel_exception_clear(&ex);
}
gint
main (gint argc,
gchar **argv)
{
CamelURL *base_url, *url;
gchar *url_string;
gint i;
GError *error = NULL;
camel_test_init (argc, argv);
camel_test_start ("URL parsing");
camel_test_push ("base URL parsing");
base_url = camel_url_new (base, &error);
if (!base_url) {
camel_test_fail (
"Could not parse %s: %s\n",
base, error->message);
}
camel_test_pull ();
camel_test_push ("base URL unparsing");
url_string = camel_url_to_string (base_url, 0);
if (strcmp (url_string, base) != 0) {
camel_test_fail ("URL <%s> unparses to <%s>\n",
base, url_string);
}
camel_test_pull ();
g_free (url_string);
for (i = 0; i < G_N_ELEMENTS (tests); i++) {
camel_test_push ("<%s> + <%s> = <%s>?", base, tests[i].url_string, tests[i].result);
url = camel_url_new_with_base (base_url, tests[i].url_string);
if (!url) {
camel_test_fail ("could not parse");
camel_test_pull ();
continue;
}
url_string = camel_url_to_string (url, 0);
if (strcmp (url_string, tests[i].result) != 0)
camel_test_fail ("got <%s>!", url_string);
g_free (url_string);
camel_test_pull ();
}
camel_test_end ();
return 0;
}
static void
update_url_account (EAccount *account, e_account_item_t item, const gchar *surl)
{
CamelURL *url;
gchar *url_string;
const gchar *target_url;
if (!account)
return;
target_url = e_account_get_string (account, item);
if (target_url && target_url[0] != '\0')
url = camel_url_new (target_url, NULL);
else
return;
camel_url_set_param (url, "owa_url", surl);
camel_url_set_param (url, "account_uid", e_account_get_string (account, E_ACCOUNT_ID_ADDRESS));
url_string = camel_url_to_string (url, 0);
e_account_set_string (account, item, url_string);
g_free (url_string);
camel_url_free (url);
}
static void
exchange_authtype_changed (GtkComboBox *dropdown, EConfig *config)
{
EMConfigTargetAccount *target = (EMConfigTargetAccount *)config->target;
int id = gtk_combo_box_get_active(dropdown);
GtkTreeModel *model;
GtkTreeIter iter;
CamelServiceAuthType *authtype;
CamelURL *url_source, *url_transport;
const char *source_url, *transport_url;
char *source_url_string, *transport_url_string;
source_url = e_account_get_string (target->account,
E_ACCOUNT_SOURCE_URL);
if (id == -1)
return;
url_source = camel_url_new (source_url, NULL);
transport_url = e_account_get_string (target->account,
E_ACCOUNT_TRANSPORT_URL);
url_transport = camel_url_new (transport_url, NULL);
model = gtk_combo_box_get_model(dropdown);
if (gtk_tree_model_iter_nth_child(model, &iter, NULL, id)) {
gtk_tree_model_get(model, &iter, 1, &authtype, -1);
if (authtype) {
camel_url_set_authmech(url_source, authtype->authproto);
camel_url_set_authmech(url_transport, authtype->authproto);
}
else {
camel_url_set_authmech(url_source, NULL);
camel_url_set_authmech(url_transport, NULL);
}
source_url_string = camel_url_to_string(url_source, 0);
transport_url_string = camel_url_to_string(url_transport, 0);
e_account_set_string(target->account, E_ACCOUNT_SOURCE_URL, source_url_string);
e_account_set_string(target->account, E_ACCOUNT_TRANSPORT_URL, transport_url_string);
g_free(source_url_string);
g_free(transport_url_string);
}
camel_url_free(url_source);
camel_url_free(url_transport);
}
static ESource *
get_source (ESourceList *list)
{
CamelURL *url;
gchar *url_string;
GSList *p, *l;
gchar **temp;
gchar *uri;
/* FIXME Wow... just... wow. If ever one needed proof that
* URL-based accounts were a bad idea, here ya go. */
url = g_malloc0 (sizeof (CamelURL));
camel_settings_save_to_url (settings, url);
url_string = camel_url_to_string (url, 0);
temp = g_strsplit (url_string, ";", -1);
g_free (url_string);
camel_url_free (url);
uri = temp[0];
l = e_source_list_peek_groups (list);
for (p = l; p != NULL; p = p->next) {
gchar *so_uri;
GSList *r, *s;
ESourceGroup *group = E_SOURCE_GROUP (p->data);
s = e_source_group_peek_sources (group);
for (r = s; r != NULL; r = r->next) {
ESource *so = E_SOURCE (r->data);
so_uri = e_source_get_uri (so);
if (so_uri) {
if (!strcmp (so_uri, uri)) {
g_free (so_uri), so_uri = NULL;
g_strfreev (temp);
return E_SOURCE (r->data);
}
g_free (so_uri), so_uri = NULL;
}
}
}
g_strfreev (temp);
return NULL;
}
/*Build/populate CamelFolderInfo structure based on the imap_build_folder_info function*/
static CamelFolderInfo *
groupwise_build_folder_info (CamelGroupwiseStore *gw_store, const gchar *parent_name, const gchar *folder_name)
{
CamelURL *url;
const gchar *name;
CamelFolderInfo *fi;
CamelGroupwiseStorePrivate *priv = gw_store->priv;
fi = camel_folder_info_new ();
fi->unread = -1;
fi->total = -1;
if (parent_name) {
if (strlen (parent_name) > 0)
fi->full_name = g_strconcat(parent_name, "/", folder_name, NULL);
else
fi->full_name = g_strdup (folder_name);
} else
fi->full_name = g_strdup (folder_name);
url = camel_url_new (priv->base_url,NULL);
g_free (url->path);
url->path = g_strdup_printf("/%s", fi->full_name);
fi->uri = camel_url_to_string (url,CAMEL_URL_HIDE_ALL);
camel_url_free (url);
name = strrchr (fi->full_name,'/');
if (name == NULL)
name = fi->full_name;
else
name++;
if (!strcmp (folder_name, "Sent Items"))
fi->flags |= CAMEL_FOLDER_TYPE_SENT;
else if (!strcmp (folder_name, "Mailbox"))
fi->flags |= CAMEL_FOLDER_TYPE_INBOX;
else if (!strcmp (folder_name, "Trash"))
fi->flags |= CAMEL_FOLDER_TYPE_TRASH;
else if (!strcmp (folder_name, "Junk Mail"))
fi->flags |= CAMEL_FOLDER_TYPE_JUNK;
if (groupwise_is_system_folder (folder_name))
fi->flags |= CAMEL_FOLDER_SYSTEM;
fi->name = g_strdup (name);
return fi;
}
static void
owa_editor_entry_changed(GtkWidget *entry, EConfig *config)
{
const char *uri, *ssl = NULL;
CamelURL *url, *owaurl = NULL;
char *url_string;
EMConfigTargetAccount *target = (EMConfigTargetAccount *)config->target;
GtkWidget *button = g_object_get_data((GObject *)entry, "authenticate-button");
int active = FALSE;
/* NB: we set the button active only if we have a parsable uri entered */
const char * target_url = e_account_get_string(target->account, E_ACCOUNT_SOURCE_URL);
if (target_url && target_url[0] != '\0')
url = camel_url_new(target_url, NULL);
else url = NULL;
uri = gtk_entry_get_text((GtkEntry *)entry);
if (uri && uri[0]) {
camel_url_set_param(url, "owa_url", uri);
owaurl = camel_url_new(uri, NULL);
if (owaurl) {
active = TRUE;
/* Reading the owa url and setting use_ssl paramemter */
if (!strcmp(owaurl->protocol, "https"))
ssl = "always";
camel_url_free(owaurl);
}
} else {
camel_url_set_param(url, "owa_url", NULL);
}
camel_url_set_param(url, "use_ssl", ssl);
gtk_widget_set_sensitive(button, active);
url_string = camel_url_to_string(url, 0);
e_account_set_string(target->account, E_ACCOUNT_SOURCE_URL, url_string);
g_free(url_string);
camel_url_free (url);
}
static char *
url_set_path_and_get_string (CamelURL *url, const char *path)
{
char *url_str;
char *tmp = NULL;
if (!path || !path[0]) {
return NULL;
}
if (path[0] != '/') {
tmp = g_strconcat ("/", path, NULL);
path = tmp;
}
camel_url_set_path (url, path);
url_str = camel_url_to_string (url, 0);
g_free (tmp);
return url_str;
}
/* FIXME: This should be a property on CamelFolder */
char *
mail_tools_folder_to_url (CamelFolder *folder)
{
CamelURL *url;
char *out;
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
url = camel_url_copy(((CamelService *)folder->parent_store)->url);
if (((CamelService *)folder->parent_store)->provider->url_flags & CAMEL_URL_FRAGMENT_IS_PATH) {
camel_url_set_fragment(url, folder->full_name);
} else {
char *name = g_alloca(strlen(folder->full_name)+2);
sprintf(name, "/%s", folder->full_name);
camel_url_set_path(url, name);
}
out = camel_url_to_string(url, CAMEL_URL_HIDE_ALL);
camel_url_free(url);
return out;
}
static gboolean
groupwise_store_construct (CamelService *service, CamelSession *session,
CamelProvider *provider, CamelURL *url,
GError **error)
{
CamelServiceClass *service_class;
CamelGroupwiseStore *groupwise_store = CAMEL_GROUPWISE_STORE (service);
CamelStore *store = CAMEL_STORE (service);
const gchar *property_value;
CamelGroupwiseStorePrivate *priv = groupwise_store->priv;
gchar *path = NULL;
d(printf ("\nin groupwise store constrcut\n"));
/* Chain up to parent's construct() method. */
service_class = CAMEL_SERVICE_CLASS (camel_groupwise_store_parent_class);
if (!service_class->construct (service, session, provider, url, error))
return FALSE;
if (!(url->host || url->user)) {
g_set_error (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_INVALID,
_("Host or user not available in url"));
}
/*storage path*/
priv->storage_path = camel_session_get_storage_path (session, service, error);
if (!priv->storage_path)
return FALSE;
/*store summary*/
path = g_alloca (strlen (priv->storage_path) + 32);
sprintf (path, "%s/.summary", priv->storage_path);
groupwise_store->summary = camel_groupwise_store_summary_new ();
camel_store_summary_set_filename ((CamelStoreSummary *)groupwise_store->summary, path);
camel_store_summary_touch ((CamelStoreSummary *)groupwise_store->summary);
camel_store_summary_load ((CamelStoreSummary *) groupwise_store->summary);
/*host and user*/
priv->server_name = g_strdup (url->host);
priv->user = g_strdup (url->user);
/*base url*/
priv->base_url = camel_url_to_string (service->url, (CAMEL_URL_HIDE_PASSWORD |
CAMEL_URL_HIDE_PARAMS |
CAMEL_URL_HIDE_AUTH) );
/*soap port*/
property_value = camel_url_get_param (url, "soap_port");
if (property_value == NULL)
priv->port = g_strdup ("7191");
else if (strlen (property_value) == 0)
priv->port = g_strdup ("7191");
else
priv->port = g_strdup (property_value);
/*filter*/
if (camel_url_get_param (url, "filter"))
store->flags |= CAMEL_STORE_FILTER_INBOX;
/*Hash Table*/
priv->id_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
priv->name_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
priv->parent_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
/*ssl*/
priv->use_ssl = g_strdup (camel_url_get_param (url, "use_ssl"));
store->flags &= ~CAMEL_STORE_VJUNK;
store->flags &= ~CAMEL_STORE_VTRASH;
return TRUE;
}
/* used by editor and druid - same code */
GtkWidget *
org_gnome_exchange_owa_url(EPlugin *epl, EConfigHookItemFactoryData *data)
{
EMConfigTargetAccount *target_account;
const char *source_url;
char *owa_url = NULL;
GtkWidget *owa_entry;
CamelURL *url;
int row;
GtkWidget *hbox, *label, *button;
target_account = (EMConfigTargetAccount *)data->config->target;
source_url = e_account_get_string (target_account->account, E_ACCOUNT_SOURCE_URL);
if (source_url && source_url[0] != '\0')
url = camel_url_new(source_url, NULL);
else
url = NULL;
if (url == NULL
|| strcmp(url->protocol, "exchange") != 0) {
if (url)
camel_url_free(url);
if (data->old
&& (label = g_object_get_data((GObject *)data->old, "authenticate-label")))
gtk_widget_destroy(label);
/* TODO: we could remove 'owa-url' from the url,
but that will lose it if we come back. Maybe a commit callback could do it */
return NULL;
}
if (data->old) {
camel_url_free(url);
return data->old;
}
owa_url = g_strdup (camel_url_get_param(url, "owa_url"));
/* if the host is null, then user+other info is dropped silently, force it to be kept */
if (url->host == NULL) {
char *uri;
camel_url_set_host(url, "");
uri = camel_url_to_string(url, 0);
e_account_set_string(target_account->account, E_ACCOUNT_SOURCE_URL, uri);
g_free(uri);
}
row = ((GtkTable *)data->parent)->nrows;
hbox = gtk_hbox_new (FALSE, 6);
label = gtk_label_new_with_mnemonic(_("_OWA URL:"));
gtk_widget_show(label);
owa_entry = gtk_entry_new();
if (!owa_url) {
if (url->host[0] != 0) {
char *uri;
/* url has hostname but not owa_url.
* Account has been created using x-c-s or evo is upgraded to 2.2
* When invoked from druid, hostname will get set after validation,
* so this condition will never be true during account creation.
*/
owa_url = construct_owa_url (url);
camel_url_set_param (url, "owa_url", owa_url);
uri = camel_url_to_string(url, 0);
e_account_set_string(target_account->account, E_ACCOUNT_SOURCE_URL, uri);
g_free(uri);
}
}
camel_url_free (url);
if (owa_url)
gtk_entry_set_text(GTK_ENTRY (owa_entry), owa_url);
gtk_label_set_mnemonic_widget((GtkLabel *)label, owa_entry);
button = gtk_button_new_with_mnemonic (_("A_uthenticate"));
gtk_widget_set_sensitive (button, owa_url && owa_url[0]);
gtk_box_pack_start (GTK_BOX (hbox), owa_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show_all(hbox);
gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0);
gtk_table_attach (GTK_TABLE (data->parent), hbox, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
g_signal_connect (owa_entry, "changed", G_CALLBACK(owa_editor_entry_changed), data->config);
g_object_set_data((GObject *)owa_entry, "authenticate-button", button);
g_signal_connect (button, "clicked", G_CALLBACK(owa_authenticate_user), data->config);
/* Track the authenticate label, so we can destroy it if e-config is to destroy the hbox */
g_object_set_data((GObject *)hbox, "authenticate-label", label);
/* check for correctness of the input in the owa_entry */
owa_editor_entry_changed (owa_entry, data->config);
g_free (owa_url);
return hbox;
}
static void
owa_authenticate_user(GtkWidget *button, EConfig *config)
{
EMConfigTargetAccount *target_account = (EMConfigTargetAccount *)config->target;
E2kAutoconfigResult result;
CamelURL *url=NULL;
gboolean remember_password;
char *url_string, *key;
const char *source_url, *id_name, *owa_url;
char *at, *user;
gboolean valid = FALSE;
ExchangeParams *exchange_params;
exchange_params = g_new0 (ExchangeParams, 1);
exchange_params->host = NULL;
exchange_params->ad_server = NULL;
exchange_params->mailbox = NULL;
exchange_params->owa_path = NULL;
exchange_params->is_ntlm = TRUE;
source_url = e_account_get_string (target_account->account, E_ACCOUNT_SOURCE_URL);
if (source_url && source_url[0] != '\0')
url = camel_url_new(source_url, NULL);
if (url && url->user == NULL) {
id_name = e_account_get_string (target_account->account, E_ACCOUNT_ID_ADDRESS);
if (id_name) {
at = strchr(id_name, '@');
user = g_alloca(at-id_name+1);
memcpy(user, id_name, at-id_name);
user[at-id_name] = 0;
camel_url_set_user (url, user);
}
}
/* validate_user() CALLS GTK!!!
THIS IS TOTALLY UNNACCEPTABLE!!!!!!!!
It must use camel_session_ask_password, and it should return an exception for any problem,
which should then be shown using e-error */
owa_url = camel_url_get_param (url, "owa_url");
if (camel_url_get_param (url, "authmech"))
exchange_params->is_ntlm = TRUE;
else
exchange_params->is_ntlm = FALSE;
camel_url_set_authmech (url, exchange_params->is_ntlm ? "NTLM" : "Basic");
key = camel_url_to_string (url, CAMEL_URL_HIDE_PASSWORD | CAMEL_URL_HIDE_PARAMS);
/* Supress the trailing slash */
key [strlen(key) -1] = 0;
valid = e2k_validate_user (owa_url, key, &url->user, exchange_params,
&remember_password, &result,
GTK_WINDOW (gtk_widget_get_toplevel (button)));
g_free (key);
if (!valid && result != E2K_AUTOCONFIG_CANCELLED)
print_error (owa_url, result);
camel_url_set_host (url, valid ? exchange_params->host : "");
if (valid)
camel_url_set_param (url, "save-passwd", remember_password? "true" : "false");
camel_url_set_param (url, "ad_server", valid ? exchange_params->ad_server: NULL);
camel_url_set_param (url, "mailbox", valid ? exchange_params->mailbox : NULL);
camel_url_set_param (url, "owa_path", valid ? exchange_params->owa_path : NULL);
g_free (exchange_params->owa_path);
g_free (exchange_params->mailbox);
g_free (exchange_params->host);
g_free (exchange_params->ad_server);
g_free (exchange_params);
if (valid) {
url_string = camel_url_to_string (url, 0);
e_account_set_string (target_account->account, E_ACCOUNT_SOURCE_URL, url_string);
e_account_set_string (target_account->account, E_ACCOUNT_TRANSPORT_URL, url_string);
e_account_set_bool (target_account->account, E_ACCOUNT_SOURCE_SAVE_PASSWD, remember_password);
g_free (url_string);
}
camel_url_free (url);
}
ECalComponent*
kolab_cal_util_fb_new_ecalcomp_from_request (KolabUtilHttpJob *job,
Kolab_conv_freebusy_type listtype,
GError **err)
{
CamelURL *camel_url = NULL;
gchar *url_string = NULL;
gchar *servername = NULL;
gboolean use_ssl = FALSE;
gssize nbytes = 0;
ECalComponent *ecalcomp = NULL;
GError *tmp_err = NULL;
/* preconditions */
g_assert (job != NULL);
g_assert (job->buffer == NULL);
g_return_val_if_fail (err == NULL || *err == NULL, NULL);
url_string = camel_url_to_string (job->url, 0);
g_assert (url_string != NULL);
servername = g_strdup (job->url->host);
use_ssl = kolab_util_http_protocol_is_ssl (url_string);
g_free (url_string);
url_string = kolabconv_cal_util_freebusy_new_fb_url (servername,
job->url->user,
use_ssl,
listtype);
g_assert (url_string != NULL);
g_debug ("%s: \n\t\t\t\t%s", __func__, url_string);
/* FIXME create a new extended CamelURL from url_string
*
* - merge the old and the new CamelURL
* - pay attention to passwd,authmech,... set
* on the original CamelURL
*
*/
camel_url = camel_url_new (url_string, NULL);
g_assert (camel_url != NULL);
g_free (url_string);
camel_url_set_user (camel_url, job->url->user);
/* TODO authmech ? */
camel_url_set_port (camel_url, job->url->port);
if (job->url->query) camel_url_set_query (camel_url, job->url->query);
if (job->url->fragment) camel_url_set_fragment (camel_url, job->url->fragment);
camel_url_free (job->url);
job->url = camel_url;
job->buffer = g_byte_array_new ();
g_assert (job->buffer != NULL);
/* issue HTTP GET request */
nbytes = kolab_util_http_get (job, &tmp_err);
if (tmp_err != NULL)
goto skip;
job->nbytes = nbytes; /* save number of bytes read since buffer will be destroyed */
g_debug ("%s: read %d bytes", __func__, nbytes);
/* create new ECalComponent */
ecalcomp = kolabconv_cal_util_freebusy_ecalcomp_new_from_ics ((gchar*)(job->buffer->data),
nbytes,
&tmp_err);
skip:
if ((ecalcomp == NULL) && (tmp_err != NULL))
g_propagate_error (err, tmp_err);
g_byte_array_unref (job->buffer);
job->buffer = NULL;
g_free (servername);
/* postconditions */
g_assert (job->buffer == NULL);
return ecalcomp;
}
void
imap_headers_commit (EPlugin *efp, EConfigHookItemFactoryData *data)
{
EMConfigTargetAccount *target_account;
EAccount *account;
gboolean use_imap = g_getenv ("USE_IMAP") != NULL;
target_account = (EMConfigTargetAccount *)data->config->target;
account = target_account->account;
if (g_str_has_prefix (account->source->url, "imap://") ||
(use_imap && g_str_has_prefix (account->source->url, "groupwise://"))) {
EAccount *temp = NULL;
EAccountList *accounts = mail_config_get_accounts ();
CamelURL *url = NULL;
CamelException ex;
GtkTreeModel *model;
GtkTreeIter iter;
GString *str;
gchar *header = NULL;
str = g_string_new("");
temp = mail_config_get_account_by_source_url (account->source->url);
url = camel_url_new (e_account_get_string(account, E_ACCOUNT_SOURCE_URL), &ex);
model = gtk_tree_view_get_model (ui->custom_headers_tree);
if (gtk_tree_model_get_iter_first(model, &iter)) {
do
{
header = NULL;
gtk_tree_model_get (model, &iter, 0, &header, -1);
str = g_string_append (str, g_strstrip(header));
str = g_string_append (str, " ");
g_free (header);
} while (gtk_tree_model_iter_next(model, &iter));
}
header = g_strstrip(g_strdup(str->str));
camel_url_set_param (url, "imap_custom_headers", header);
g_free (header);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->all_headers))) {
camel_url_set_param (url, "all_headers", "1");
camel_url_set_param (url, "basic_headers", NULL);
} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->basic_headers))) {
camel_url_set_param (url, "basic_headers", "1");
camel_url_set_param (url, "all_headers", NULL);
} else {
camel_url_set_param (url, "all_headers", NULL);
camel_url_set_param (url, "basic_headers", NULL);
}
e_account_set_string (temp, E_ACCOUNT_SOURCE_URL, camel_url_to_string (url, 0));
camel_url_free (url);
g_string_free (str, TRUE);
e_account_list_change (accounts, temp);
e_account_list_save (accounts);
}
}
static CamelFolderInfo *
scan_dir (CamelStore *store, CamelURL *url, GHashTable *visited, CamelFolderInfo *parent, const gchar *root,
const gchar *name, guint32 flags, GError **error)
{
CamelFolderInfo *folders, *tail, *fi;
GHashTable *folder_hash;
const gchar *dent;
GDir *dir;
tail = folders = NULL;
if (!(dir = g_dir_open (root, 0, NULL)))
return NULL;
folder_hash = g_hash_table_new (g_str_hash, g_str_equal);
/* FIXME: it would be better if we queue'd up the recursive
* scans till the end so that we can limit the number of
* directory descriptors open at any given time... */
while ((dent = g_dir_read_name (dir))) {
gchar *short_name, *full_name, *path, *ext;
struct stat st;
if (dent[0] == '.')
continue;
if (ignore_file (dent, FALSE))
continue;
path = g_strdup_printf("%s/%s", root, dent);
if (g_stat (path, &st) == -1) {
g_free (path);
continue;
}
#ifndef G_OS_WIN32
if (S_ISDIR (st.st_mode)) {
struct _inode in = { st.st_dev, st.st_ino };
if (g_hash_table_lookup (visited, &in)) {
g_free (path);
continue;
}
}
#endif
short_name = g_strdup (dent);
if ((ext = strrchr(short_name, '.')) && !strcmp(ext, ".sbd"))
*ext = '\0';
if (name != NULL)
full_name = g_strdup_printf("%s/%s", name, short_name);
else
full_name = g_strdup (short_name);
if ((fi = g_hash_table_lookup (folder_hash, short_name)) != NULL) {
g_free (short_name);
g_free (full_name);
if (S_ISDIR (st.st_mode)) {
fi->flags =(fi->flags & ~CAMEL_FOLDER_NOCHILDREN) | CAMEL_FOLDER_CHILDREN;
} else {
fi->flags &= ~CAMEL_FOLDER_NOSELECT;
}
} else {
fi = camel_folder_info_new ();
fi->parent = parent;
camel_url_set_fragment (url, full_name);
fi->uri = camel_url_to_string (url, 0);
fi->name = short_name;
fi->full_name = full_name;
fi->unread = -1;
fi->total = -1;
if (S_ISDIR (st.st_mode))
fi->flags = CAMEL_FOLDER_NOSELECT;
else
fi->flags = CAMEL_FOLDER_NOCHILDREN;
if (tail == NULL)
folders = fi;
else
tail->next = fi;
tail = fi;
g_hash_table_insert (folder_hash, fi->name, fi);
}
if (!S_ISDIR (st.st_mode)) {
fill_fi (store, fi, flags);
} else if ((flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE)) {
struct _inode in = { st.st_dev, st.st_ino };
if (g_hash_table_lookup (visited, &in) == NULL) {
#ifndef G_OS_WIN32
struct _inode *inew = g_new (struct _inode, 1);
*inew = in;
g_hash_table_insert (visited, inew, inew);
#endif
if ((fi->child = scan_dir (store, url, visited, fi, path, fi->full_name, flags, error)))
fi->flags |= CAMEL_FOLDER_CHILDREN;
else
fi->flags =(fi->flags & ~CAMEL_FOLDER_CHILDREN) | CAMEL_FOLDER_NOCHILDREN;
}
}
g_free (path);
}
g_dir_close (dir);
g_hash_table_destroy (folder_hash);
return folders;
}
/* The worker thread function with all the complex
* logic in it! Big fat beast! Please watch your
* children ... */
static void
synch_worker (struct account_synch_msg *m)
{
ScalixAccountSynch *sxas;
ScalixAccountSynchPrivate *priv;
CamelException ex;
CamelStore *store;
CamelFolderInfo *ftree;
CamelFolderInfo *sf;
CamelSession *cs;
const char *uri;
gboolean res;
char *sversion;
char *markup;
sxas = SCALIX_ACCOUNT_SYNCH (m->sxas);
priv = SCALIX_ACCOUNT_SYNCH_GET_PRIVATE (sxas);
uri = e_account_get_string (priv->account, E_ACCOUNT_SOURCE_URL);
g_print ("SxAS: starting synch for %s\n", uri);
signal_progress (sxas, 1, _("Trying to connect to server"));
camel_exception_init (&ex);
cs = scalix_camel_session_get_default ();
camel_session_set_online (cs, TRUE);
store = camel_session_get_store (cs, uri, &ex);
if (store == NULL) {
signal_error (sxas, _("Authentication failed. Check for correct hostname, username and password."));
return;
}
/* Must be online! */
camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (store),
CAMEL_OFFLINE_STORE_NETWORK_AVAIL,
&ex);
camel_service_connect (CAMEL_SERVICE (store), &ex);
if (camel_exception_is_set (&ex)) {
signal_error (sxas, _("Error while trying to connect to server."));
return;
}
/* Always check for minimal required server version */
signal_progress (sxas, 10, _("Checking version of Scalix server"));
g_print ("SxAS: Checking for minimal server version\n");
sversion = NULL;
camel_object_get (store, NULL,
CAMEL_SCALIX_STORE_SERVER_VERSION, &sversion, NULL);
res = scalix_check_min_server_version (sversion);
if (res == FALSE) {
signal_error (sxas, _("Wrong version of Scalix server detected"));
return;
}
m->sversion = g_strdup (sversion);
g_print ("SxAS: sversion:%s\n", m->sversion);
markup = g_markup_printf_escaped (MSG_SVER, sversion);
signal_info (sxas, markup);
g_free (markup);
signal_progress (sxas, 20, _("Getting list of folders"));
ftree = camel_store_get_folder_info (store,
NULL,
CAMEL_STORE_FOLDER_INFO_RECURSIVE |
CAMEL_SCALIX_STORE_SHOW_SFOLDER, &ex);
if (ftree == NULL) {
camel_object_unref (store);
signal_error (sxas, _("Could not obtain folder listening"));
return;
}
/* Calendar */
signal_progress (sxas, 30, _("Loading calendar data..."));
synch_data (sxas, ftree, CAMEL_SCALIX_FOLDER_CALENDAR, 30);
m->esg_cals = create_group (priv->account, "Calendar");
sync_source_group (priv->account,
m->esg_cals, CAMEL_SCALIX_FOLDER_CALENDAR, ftree);
/* Contacts */
signal_progress (sxas, 60, _("Loading contacts..."));
synch_data (sxas, ftree, CAMEL_SCALIX_FOLDER_CONTACT, 60);
m->esg_cnts = create_group (priv->account, "Contacts");
sync_source_group (priv->account,
m->esg_cnts, CAMEL_SCALIX_FOLDER_CONTACT, ftree);
create_ldap_source (priv->account, m->esg_cnts);
/* Sent Items and Drafts Folder */
if (priv->synch_dfolder) {
char *url_str;
CamelURL *url;
url = camel_url_new (uri, NULL);
signal_progress (sxas, 95, _("Synchronizing additional data"));
sf = folder_tree_find_special (ftree, CAMEL_SCALIX_FOLDER_SENT);
if (url && sf) {
url_str = url_set_path_and_get_string (url, sf->full_name);
e_account_set_string (priv->account,
E_ACCOUNT_SENT_FOLDER_URI, url_str);
g_free (url_str);
}
sf = folder_tree_find_special (ftree, CAMEL_SCALIX_FOLDER_DRAFTS);
if (url && sf) {
url_str = url_set_path_and_get_string (url, sf->full_name);
e_account_set_string (priv->account,
E_ACCOUNT_DRAFTS_FOLDER_URI, url_str);
g_free (url_str);
}
if (url) {
gboolean save_pw;
camel_url_set_path (url, NULL);
if (url->authmech == NULL) {
camel_url_set_authmech (url, "PLAIN");
}
url_str = camel_url_to_string (url, 0);
e_account_set_string (priv->account,
E_ACCOUNT_TRANSPORT_URL, url_str);
save_pw = e_account_get_bool (priv->account,
E_ACCOUNT_SOURCE_SAVE_PASSWD);
e_account_set_bool (priv->account,
E_ACCOUNT_TRANSPORT_SAVE_PASSWD, save_pw);
}
if (url) {
camel_url_free (url);
}
}
m->success = TRUE;
g_print ("SxAS: DONE!\n");
camel_object_unref (store);
signal_progress (sxas, 100, _("Done loading"));
signal_info (sxas, _("Initial loading complete. Please click Forward."));
g_print ("SxAS: Freeing DONE\n");
return;
}
static void
groupwise_store_construct (CamelService *service, CamelSession *session,
CamelProvider *provider, CamelURL *url,
CamelException *ex)
{
CamelGroupwiseStore *groupwise_store = CAMEL_GROUPWISE_STORE (service);
CamelStore *store = CAMEL_STORE (service);
const char *property_value;
CamelGroupwiseStorePrivate *priv = groupwise_store->priv;
char *path = NULL;
d(printf ("\nin groupwise store constrcut\n"));
CAMEL_SERVICE_CLASS (parent_class)->construct (service, session, provider, url, ex);
if (camel_exception_is_set (ex))
return;
if (!(url->host || url->user)) {
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_INVALID,
_("Host or user not available in url"));
}
/*XXX: The number 3 assigned to the list_loaded variable denotes
* the number of times the get_folder_info is called during startup.
* We are just trying to minimize the call.
* This is a dirty hack. But it *WORKS*
*/
groupwise_store->list_loaded = 3;
/*storage path*/
priv->storage_path = camel_session_get_storage_path (session, service, ex);
if (!priv->storage_path)
return;
/*store summary*/
path = g_alloca (strlen (priv->storage_path) + 32);
sprintf (path, "%s/.summary", priv->storage_path);
groupwise_store->summary = camel_groupwise_store_summary_new ();
camel_store_summary_set_filename ((CamelStoreSummary *)groupwise_store->summary, path);
camel_store_summary_touch ((CamelStoreSummary *)groupwise_store->summary);
camel_store_summary_load ((CamelStoreSummary *) groupwise_store->summary);
/*host and user*/
priv->server_name = g_strdup (url->host);
priv->user = g_strdup (url->user);
/*base url*/
priv->base_url = camel_url_to_string (service->url, (CAMEL_URL_HIDE_PASSWORD |
CAMEL_URL_HIDE_PARAMS |
CAMEL_URL_HIDE_AUTH) );
/*soap port*/
property_value = camel_url_get_param (url, "soap_port");
if (property_value == NULL)
priv->port = g_strdup ("7191");
else if(strlen(property_value) == 0)
priv->port = g_strdup ("7191");
else
priv->port = g_strdup (property_value);
/*filter*/
if (camel_url_get_param (url, "filter"))
store->flags |= CAMEL_STORE_FILTER_INBOX;
/*Hash Table*/
priv->id_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
priv->name_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
priv->parent_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
/*ssl*/
priv->use_ssl = g_strdup (camel_url_get_param (url, "use_ssl"));
store->flags &= ~CAMEL_STORE_VJUNK;
store->flags &= ~CAMEL_STORE_VTRASH;
}
/* ************************************************************************* */
static GNOME_Evolution_Addressbook_CallStatus
e_book_backend_scalix_load_source (EBookBackend * backend,
ESource * source, gboolean only_if_exists)
{
EBookBackendScalix *bs;
EBookBackendScalixPrivate *priv;
ScalixContainer *container;
const char *prop_ssl;
gchar *uri;
bs = E_BOOK_BACKEND_SCALIX (backend);
priv = E_BOOK_BACKEND_SCALIX_GET_PRIVATE (bs);
if (priv->container != NULL) {
/* Source already loaded! */
return GNOME_Evolution_Addressbook_Success;
}
uri = e_source_get_uri (source);
if ((prop_ssl = e_source_get_property (source, "use_ssl"))) {
CamelURL *url;
url = camel_url_new (uri, NULL);
camel_url_set_param (url, "use_ssl", prop_ssl);
g_free (uri);
uri = camel_url_to_string (url, 0);
}
container = scalix_container_open (uri);
g_free (uri);
if (container == NULL) {
return GNOME_Evolution_Addressbook_OtherError;
}
e_book_backend_set_is_loaded (E_BOOK_BACKEND (backend), TRUE);
e_book_backend_set_is_writable (E_BOOK_BACKEND (backend), TRUE);
if (only_if_exists == FALSE) {
GLOG_CAT_DEBUG (&slbook, "Only if exists == FALSE");
g_object_set (container, "only_if_exists", FALSE,
"type", "Contacts", NULL);
}
priv->container = container;
// go online here?
if (priv->mode == GNOME_Evolution_Addressbook_MODE_REMOTE) {
go_online (bs);
}
g_signal_connect (container, "object_added",
G_CALLBACK (container_object_added_cb),
(gpointer) backend);
g_signal_connect (container, "object_removed",
G_CALLBACK (container_object_removed_cb),
(gpointer) backend);
g_signal_connect (container, "object_changed",
G_CALLBACK (container_object_changed_cb),
(gpointer) backend);
return GNOME_Evolution_Addressbook_Success;
}
