static void
ep_remember_password (EPassMsg *msg)
{
gchar *password;
EUri *uri;
GError *error = NULL;
password = g_hash_table_lookup (password_cache, msg->key);
if (password == NULL) {
g_warning ("Password for key \"%s\" not found", msg->key);
goto exit;
}
uri = ep_keyring_uri_new (msg->key, &msg->error);
if (uri == NULL)
goto exit;
/* Only remove the password from the session hash
* if the keyring insertion was successful. */
if (ep_keyring_insert_password (uri->user, uri->host, uri->protocol, msg->key, password, &error))
g_hash_table_remove (password_cache, msg->key);
if (error != NULL)
g_propagate_error (&msg->error, error);
e_uri_free (uri);
exit:
if (!msg->noreply)
e_flag_set (msg->done);
}
static EUri *
ep_keyring_uri_new (const gchar *string,
GError **error)
{
EUri *uri;
uri = e_uri_new (string);
g_return_val_if_fail (uri != NULL, NULL);
/* LDAP URIs do not have usernames, so use the URI as the username. */
if (uri->user == NULL && uri->protocol != NULL &&
(strcmp (uri->protocol, "ldap") == 0|| strcmp (uri->protocol, "google") == 0))
uri->user = g_strdelimit (g_strdup (string), "/=", '_');
/* Make sure the URI has the required components. */
if (uri->user == NULL && uri->host == NULL) {
g_set_error_literal (
error, EP_KEYRING_ERROR,
GNOME_KEYRING_RESULT_BAD_ARGUMENTS,
_("Keyring key is unusable: no user or host name"));
e_uri_free (uri);
uri = NULL;
}
return uri;
}
static void
create_ldap_source (EAccount * account, ESourceGroup * group)
{
ESource *source;
EUri *euri;
char *uri;
char *uid;
xmlNodePtr node;
euri = e_uri_new (account->source->url);
uri = g_strdup_printf ("ldap://%s:389/o=Scalix?sub", euri->host);
uid = g_strdup_printf ("system-ldap@%s", account->uid);
node = xmlNewNode (NULL, "source");
xmlSetProp (node, "uid", uid);
xmlSetProp (node, "name", _("System"));
xmlSetProp (node, "uri", uri);
source = e_source_new_from_xml_node (node);
xmlFreeNode (node);
e_source_set_property (source, "completion", "TRUE");
if (!e_source_group_add_source (group, source, 1)) {
g_print ("Could not add ldap source\n");
}
g_free (uri);
g_free (uid);
e_uri_free (euri);
}
static ESourceGroup *
create_group (EAccount * account, const char *type_string)
{
ESourceGroup *gfake;
char *uid;
char *base_uri;
xmlDocPtr doc;
xmlNodePtr root;
EUri *euri;
const char *surl;
uid = g_strdup_printf ("%s@%s", type_string, account->uid);
doc = xmlNewDoc ("1.0");
root = xmlNewDocNode (doc, NULL, "group", NULL);
xmlDocSetRootElement (doc, root);
surl = e_account_get_string (account, E_ACCOUNT_SOURCE_URL);
euri = e_uri_new (surl);
base_uri = create_base_uri (euri);
e_uri_free (euri);
xmlSetProp (root, "uid", uid);
xmlSetProp (root, "name", account->name);
xmlSetProp (root, "base_uri", base_uri);
gfake = e_source_group_new_from_xmldoc (doc);
g_free (base_uri);
g_free (uid);
xmlFreeDoc (doc);
return gfake;
}
static void
addressbook_authenticate (EBook *book,
gpointer data)
{
gchar *auth;
gchar *user;
gchar *passwd;
gchar *str_uri;
gchar *pass_key;
gchar *auth_domain;
gchar *component_name;
EUri *e_uri;
ESource *source = (ESource *)data;
auth = (gchar *)e_source_get_property (source, "auth");
auth_domain = (gchar *)e_source_get_property (source, "auth-domain");
component_name = auth_domain ? auth_domain : "Addressbook";
if (auth && !strcmp ("plain/password", auth))
user = (gchar *)e_source_get_property (source, "user");
else
user = (gchar *)e_source_get_property (source, "email_addr");
if (!user)
user = "";
str_uri = e_source_get_uri (source);
e_uri = e_uri_new (str_uri);
pass_key = e_uri_to_string (e_uri, FALSE);
e_uri_free (e_uri);
passwd = e_passwords_get_password (component_name, pass_key);
if (passwd)
passwd = "";
if (book)
if (!e_book_authenticate_user (book, user, passwd, auth, NULL))
LOG (g_warning ("Authentication failed"));
g_free (pass_key);
g_free (str_uri);
return;
}
static void
ep_forget_password (EPassMsg *msg)
{
GList *passwords;
EUri *uri;
GError *error = NULL;
g_hash_table_remove (password_cache, msg->key);
uri = ep_keyring_uri_new (msg->key, &msg->error);
if (uri == NULL)
goto exit;
/* Find all Evolution passwords matching the URI and delete them.
*
* XXX We didn't always store protocols in the keyring, so for
* backward-compatibility we need to lookup passwords by user
* and host only (no protocol). But we do send the protocol
* to ep_keyring_delete_passwords(), which also knows about
* the backward-compatibility issue and will filter the list
* appropriately. */
passwords = ep_keyring_lookup_passwords (uri->user, uri->host, NULL, &error);
if (passwords != NULL) {
ep_keyring_delete_passwords (uri->user, uri->host, uri->protocol, passwords, &error);
gnome_keyring_found_list_free (passwords);
}
if (error != NULL)
g_propagate_error (&msg->error, error);
e_uri_free (uri);
exit:
if (!msg->noreply)
e_flag_set (msg->done);
}
static EPublishUri *
migrateURI (const gchar *xml, xmlDocPtr doc)
{
GConfClient *client;
GSList *uris, *l, *events = NULL;
xmlChar *location, *enabled, *frequency, *username;
xmlNodePtr root, p;
EPublishUri *uri;
gchar *password, *temp;
EUri *euri;
client = gconf_client_get_default ();
uris = gconf_client_get_list (client, "/apps/evolution/calendar/publish/uris", GCONF_VALUE_STRING, NULL);
l = uris;
while (l && l->data) {
gchar *str = l->data;
if (strcmp (xml, str) == 0) {
uris = g_slist_remove (uris, str);
g_free (str);
}
l = g_slist_next (l);
}
uri = g_new0 (EPublishUri, 1);
root = doc->children;
location = xmlGetProp (root, (const unsigned char *)"location");
enabled = xmlGetProp (root, (const unsigned char *)"enabled");
frequency = xmlGetProp (root, (const unsigned char *)"frequency");
username = xmlGetProp (root, (const unsigned char *)"username");
euri = e_uri_new ((const char *)location);
if (!euri) {
g_warning ("Could not form the uri for %s \n", location);
goto cleanup;
}
if (euri->user)
g_free (euri->user);
euri->user = g_strdup ((const char *)username);
temp = e_uri_to_string (euri, FALSE);
uri->location = g_strdup_printf ("dav://%s", strstr (temp, "//") + 2);
g_free (temp);
e_uri_free (euri);
if (enabled != NULL)
uri->enabled = atoi ((char *)enabled);
if (frequency != NULL)
uri->publish_frequency = atoi ((char *)frequency);
uri->publish_format = URI_PUBLISH_AS_FB;
password = e_passwords_get_password ("Calendar", (char *)location);
if (password) {
e_passwords_forget_password ("Calendar", (char *)location);
e_passwords_add_password (uri->location, password);
e_passwords_remember_password ("Calendar", uri->location);
}
for (p = root->children; p != NULL; p = p->next) {
xmlChar *uid = xmlGetProp (p, (const unsigned char *)"uid");
if (strcmp ((char *)p->name, "source") == 0) {
events = g_slist_append (events, uid);
} else {
g_free (uid);
}
}
uri->events = events;
uris = g_slist_prepend (uris, e_publish_uri_to_xml (uri));
gconf_client_set_list (client, "/apps/evolution/calendar/publish/uris", GCONF_VALUE_STRING, uris, NULL);
g_slist_foreach (uris, (GFunc) g_free, NULL);
g_slist_free (uris);
g_object_unref (client);
cleanup:
xmlFree (location);
xmlFree (enabled);
xmlFree (frequency);
xmlFree (username);
xmlFreeDoc (doc);
return uri;
}
static void
ep_get_password (EPassMsg *msg)
{
EUri *uri;
GList *passwords;
gchar *password;
GError *error = NULL;
/* Check the in-memory cache first. */
password = g_hash_table_lookup (password_cache, msg->key);
if (password != NULL) {
msg->password = g_strdup (password);
goto exit;
}
uri = ep_keyring_uri_new (msg->key, &msg->error);
if (uri == NULL)
goto exit;
/* Find the first Evolution password that matches the URI. */
passwords = ep_keyring_lookup_passwords (uri->user, uri->host, uri->protocol, &error);
if (passwords != NULL) {
GList *iter = passwords;
while (iter != NULL) {
GnomeKeyringFound *found = iter->data;
if (default_keyring && strcmp (default_keyring, found->keyring) != 0) {
g_message ("Received a password from keyring '%s'. But looking for the password from '%s' keyring\n", found->keyring, default_keyring);
iter = g_list_next (iter);
continue;
}
if (ep_keyring_validate (uri->user, uri->host, uri->protocol, found->attributes)) {
msg->password = g_strdup (found->secret);
break;
}
iter = g_list_next (iter);
}
gnome_keyring_found_list_free (passwords);
}
if (msg->password != NULL)
goto done;
/* Clear the previous error, if there was one. If the error was
* something other than NO_MATCH then it's likely to occur again. */
if (error != NULL)
g_clear_error (&error);
/* XXX We didn't always store protocols in the keyring, so for
* backward-compatibility we also need to lookup passwords
* by user and host only (no protocol). */
passwords = ep_keyring_lookup_passwords (uri->user, uri->host, NULL, &error);
if (passwords != NULL) {
GList *iter = passwords;
while (iter != NULL) {
GnomeKeyringFound *found = iter->data;
if (default_keyring && strcmp (default_keyring, found->keyring) != 0) {
g_message ("Received a password from keyring '%s'. But looking for the password from '%s' keyring\n", found->keyring, default_keyring);
iter = g_list_next (iter);
continue;
}
if (ep_keyring_validate (uri->user, uri->host, NULL, found->attributes)) {
msg->password = g_strdup (found->secret);
break;
}
iter = g_list_next (iter);
}
gnome_keyring_found_list_free (passwords);
}
done:
/* Not finding the requested key is acceptable, but we still
* want to leave an informational message on the terminal. */
if (g_error_matches (error, EP_KEYRING_ERROR, GNOME_KEYRING_RESULT_NO_MATCH)) {
g_message ("%s", error->message);
g_error_free (error);
} else if (error != NULL)
g_propagate_error (&msg->error, error);
e_uri_free (uri);
exit:
if (!msg->noreply)
e_flag_set (msg->done);
}
