* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "config.h"
#include "empathy-server-sasl-handler.h"
-#include <telepathy-glib/util.h>
+#include <tp-account-widgets/tpaw-keyring.h>
+#include <telepathy-glib/telepathy-glib-dbus.h>
+
+#include "empathy-sasl-mechanisms.h"
+#include "extensions.h"
#define DEBUG_FLAG EMPATHY_DEBUG_SASL
#include "empathy-debug.h"
-#include "empathy-utils.h"
enum {
PROP_CHANNEL = 1,
/* signal enum */
enum {
+ AUTH_PASSWORD_FAILED,
INVALIDATED,
LAST_SIGNAL,
};
TpAccount *account;
GSimpleAsyncResult *result;
+
+ gchar *password;
+ gboolean save_password;
+
+ GSimpleAsyncResult *async_init_res;
} EmpathyServerSASLHandlerPriv;
-G_DEFINE_TYPE (EmpathyServerSASLHandler, empathy_server_sasl_handler,
- G_TYPE_OBJECT);
+static void async_initable_iface_init (GAsyncInitableIface *iface);
-#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyServerSASLHandler);
+G_DEFINE_TYPE_WITH_CODE (EmpathyServerSASLHandler, empathy_server_sasl_handler,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init));
-static const gchar *sasl_statuses[] = {
- "not started",
- "in progress",
- "server succeeded",
- "client accepted",
- "succeeded",
- "server failed",
- "client failed",
-};
+static void
+empathy_server_sasl_handler_set_password_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GError *error = NULL;
+
+ if (!tpaw_keyring_set_account_password_finish (TP_ACCOUNT (source), result,
+ &error))
+ {
+ DEBUG ("Failed to set password: %s", error->message);
+ g_clear_error (&error);
+ }
+ else
+ {
+ DEBUG ("Password set successfully.");
+ }
+}
+
+static gboolean
+empathy_server_sasl_handler_give_password (gpointer data)
+{
+ EmpathyServerSASLHandler *self = data;
+ EmpathyServerSASLHandlerPriv *priv = self->priv;
+
+ empathy_server_sasl_handler_provide_password (self,
+ priv->password, FALSE);
+
+ return FALSE;
+}
static void
-sasl_status_changed_cb (TpChannel *channel,
- TpSASLStatus status,
- const gchar *error,
- GHashTable *details,
- gpointer user_data,
- GObject *weak_object)
+empathy_server_sasl_handler_get_password_async_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
{
- EmpathyServerSASLHandlerPriv *priv = GET_PRIV (weak_object);
+ EmpathyServerSASLHandlerPriv *priv;
+ const gchar *password;
+ GError *error = NULL;
- DEBUG ("SASL status changed to '%s'", sasl_statuses[status]);
+ priv = EMPATHY_SERVER_SASL_HANDLER (user_data)->priv;
- if (status == TP_SASL_STATUS_SERVER_SUCCEEDED)
+ password = tpaw_keyring_get_account_password_finish (TP_ACCOUNT (source),
+ result, &error);
+
+ if (password != NULL)
{
- tp_cli_channel_interface_sasl_authentication_call_accept_sasl (
- priv->channel, -1, NULL, NULL, NULL, NULL);
+ priv->password = g_strdup (password);
- tp_cli_channel_call_close (priv->channel, -1,
- NULL, NULL, NULL, NULL);
+ /* Do this in an idle so the async result will get there
+ * first. */
+ g_idle_add (empathy_server_sasl_handler_give_password, user_data);
}
+
+ g_simple_async_result_complete (priv->async_init_res);
+ tp_clear_object (&priv->async_init_res);
+}
+
+static void
+empathy_server_sasl_handler_init_async (GAsyncInitable *initable,
+ gint io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ EmpathyServerSASLHandler *self = EMPATHY_SERVER_SASL_HANDLER (initable);
+ EmpathyServerSASLHandlerPriv *priv = self->priv;
+
+ g_assert (priv->account != NULL);
+
+ priv->async_init_res = g_simple_async_result_new (G_OBJECT (self),
+ callback, user_data, empathy_server_sasl_handler_new_async);
+
+ tpaw_keyring_get_account_password_async (priv->account,
+ empathy_server_sasl_handler_get_password_async_cb, self);
+}
+
+static gboolean
+empathy_server_sasl_handler_init_finish (GAsyncInitable *initable,
+ GAsyncResult *res,
+ GError **error)
+{
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res),
+ error))
+ return FALSE;
+
+ return TRUE;
+}
+
+static void
+async_initable_iface_init (GAsyncInitableIface *iface)
+{
+ iface->init_async = empathy_server_sasl_handler_init_async;
+ iface->init_finish = empathy_server_sasl_handler_init_finish;
}
static void
static void
empathy_server_sasl_handler_constructed (GObject *object)
{
- EmpathyServerSASLHandlerPriv *priv;
+ EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
GError *error = NULL;
- priv = GET_PRIV (object);
-
- tp_cli_channel_interface_sasl_authentication_connect_to_sasl_status_changed (priv->channel,
- sasl_status_changed_cb, NULL, NULL, object, &error);
-
if (error != NULL)
{
DEBUG ("Failed to connect to SASLStatusChanged: %s", error->message);
GValue *value,
GParamSpec *pspec)
{
- EmpathyServerSASLHandlerPriv *priv = GET_PRIV (object);
+ EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
switch (property_id)
{
const GValue *value,
GParamSpec *pspec)
{
- EmpathyServerSASLHandlerPriv *priv = GET_PRIV (object);
+ EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
switch (property_id)
{
static void
empathy_server_sasl_handler_dispose (GObject *object)
{
- EmpathyServerSASLHandlerPriv *priv = GET_PRIV (object);
+ EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
DEBUG ("%p", object);
G_OBJECT_CLASS (empathy_server_sasl_handler_parent_class)->dispose (object);
}
+static void
+empathy_server_sasl_handler_finalize (GObject *object)
+{
+ EmpathyServerSASLHandlerPriv *priv = EMPATHY_SERVER_SASL_HANDLER (object)->priv;
+
+ DEBUG ("%p", object);
+
+ tp_clear_pointer (&priv->password, g_free);
+
+ G_OBJECT_CLASS (empathy_server_sasl_handler_parent_class)->finalize (object);
+}
+
static void
empathy_server_sasl_handler_class_init (EmpathyServerSASLHandlerClass *klass)
{
oclass->get_property = empathy_server_sasl_handler_get_property;
oclass->set_property = empathy_server_sasl_handler_set_property;
oclass->dispose = empathy_server_sasl_handler_dispose;
+ oclass->finalize = empathy_server_sasl_handler_finalize;
g_type_class_add_private (klass, sizeof (EmpathyServerSASLHandlerPriv));
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (oclass, PROP_ACCOUNT, pspec);
+ signals[AUTH_PASSWORD_FAILED] = g_signal_new ("auth-password-failed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, 0,
+ NULL, NULL,
+ g_cclosure_marshal_generic,
+ G_TYPE_NONE, 1, G_TYPE_STRING);
+
signals[INVALIDATED] = g_signal_new ("invalidated",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0,
NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
+ g_cclosure_marshal_generic,
G_TYPE_NONE, 0);
}
}
EmpathyServerSASLHandler *
-empathy_server_sasl_handler_new (TpAccount *account,
- TpChannel *channel)
+empathy_server_sasl_handler_new_finish (GAsyncResult *result,
+ GError **error)
+{
+ GObject *object, *source_object;
+
+ source_object = g_async_result_get_source_object (result);
+
+ object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
+ result, error);
+ g_object_unref (source_object);
+
+ if (object != NULL)
+ return EMPATHY_SERVER_SASL_HANDLER (object);
+ else
+ return NULL;
+}
+
+void
+empathy_server_sasl_handler_new_async (TpAccount *account,
+ TpChannel *channel,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL);
+ g_return_if_fail (TP_IS_ACCOUNT (account));
+ g_return_if_fail (TP_IS_CHANNEL (channel));
+ g_return_if_fail (callback != NULL);
- return g_object_new (EMPATHY_TYPE_SERVER_SASL_HANDLER,
+ g_async_initable_new_async (EMPATHY_TYPE_SERVER_SASL_HANDLER,
+ G_PRIORITY_DEFAULT, NULL, callback, user_data,
"account", account,
"channel", channel,
NULL);
}
static void
-start_mechanism_with_data_cb (TpChannel *proxy,
- const GError *error,
- gpointer user_data,
- GObject *weak_object)
+auth_cb (GObject *source,
+ GAsyncResult *result,
+ gpointer user_data)
{
- if (error != NULL)
+ EmpathyServerSASLHandler *self = user_data;
+ EmpathyServerSASLHandlerPriv *priv = self->priv;
+ GError *error = NULL;
+
+ if (!empathy_sasl_auth_finish (priv->channel, result, &error))
{
- DEBUG ("Failed to start mechanism: %s", error->message);
- return;
+ if (g_error_matches (error, TP_ERROR, TP_ERROR_AUTHENTICATION_FAILED))
+ {
+ g_signal_emit (self, signals[AUTH_PASSWORD_FAILED], 0, priv->password);
+ }
+ g_clear_error (&error);
+ }
+ else
+ {
+ DEBUG ("Saving password in keyring");
+ tpaw_keyring_set_account_password_async (priv->account,
+ priv->password, priv->save_password,
+ empathy_server_sasl_handler_set_password_cb,
+ NULL);
}
- DEBUG ("Started mechanism successfully");
+ tp_channel_close_async (priv->channel, NULL, NULL);
+ g_object_unref (self);
+}
+
+static gboolean
+channel_has_may_save_response (TpChannel *channel)
+{
+ /* determine if we are permitted to save the password locally */
+ GVariant *props;
+ gboolean may_save_response;
+
+ props = tp_channel_dup_immutable_properties (channel);
+
+ if (!g_variant_lookup (props,
+ TP_PROP_CHANNEL_INTERFACE_SASL_AUTHENTICATION_MAY_SAVE_RESPONSE,
+ "b", &may_save_response))
+ {
+ DEBUG ("MaySaveResponse unknown, assuming TRUE");
+ may_save_response = TRUE;
+ }
+
+ g_variant_unref (props);
+ return may_save_response;
}
void
empathy_server_sasl_handler_provide_password (
EmpathyServerSASLHandler *handler,
- const gchar *password)
+ const gchar *password,
+ gboolean remember)
{
EmpathyServerSASLHandlerPriv *priv;
- GArray *array;
+ gboolean may_save_response;
g_return_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (handler));
- priv = GET_PRIV (handler);
+ priv = handler->priv;
- array = g_array_sized_new (TRUE, FALSE,
- sizeof (gchar), strlen (password));
+ empathy_sasl_auth_password_async (priv->channel, password,
+ auth_cb, g_object_ref (handler));
- g_array_append_vals (array, password, strlen (password));
+ DEBUG ("%sremembering the password", remember ? "" : "not ");
- DEBUG ("Calling StartMechanismWithData with our password");
+ may_save_response = channel_has_may_save_response (priv->channel);
- tp_cli_channel_interface_sasl_authentication_call_start_mechanism_with_data (
- priv->channel, -1, "X-TELEPATHY-PASSWORD", array, start_mechanism_with_data_cb,
- NULL, NULL, G_OBJECT (handler));
+ if (remember)
+ {
+ if (may_save_response)
+ {
+ g_free (priv->password);
+
+ /* We'll save the password if we manage to connect */
+ priv->password = g_strdup (password);
+ priv->save_password = TRUE;
+ }
+ else if (tp_proxy_has_interface_by_id (priv->channel,
+ EMP_IFACE_QUARK_CHANNEL_INTERFACE_CREDENTIALS_STORAGE))
+ {
+ DEBUG ("Channel implements Ch.I.CredentialsStorage");
+ }
+ else
+ {
+ DEBUG ("Asked to remember password, but doing so is not permitted");
+ }
+ }
+
+ if (!may_save_response)
+ {
+ /* delete any password present, it shouldn't be there */
+ tpaw_keyring_delete_account_password_async (priv->account, NULL, NULL);
+ }
- g_array_unref (array);
+ /* Additionally, if we implement Ch.I.CredentialsStorage, inform that
+ * whether we want to remember the password */
+ if (tp_proxy_has_interface_by_id (priv->channel,
+ EMP_IFACE_QUARK_CHANNEL_INTERFACE_CREDENTIALS_STORAGE))
+ {
+ emp_cli_channel_interface_credentials_storage_call_store_credentials (
+ TP_PROXY (priv->channel), -1, remember, NULL, NULL, NULL, NULL);
+ }
}
void
g_return_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (handler));
- priv = GET_PRIV (handler);
+ priv = handler->priv;
DEBUG ("Cancelling SASL mechanism...");
g_return_val_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (handler), NULL);
- priv = GET_PRIV (handler);
+ priv = handler->priv;
return priv->account;
}
+
+TpChannel *
+empathy_server_sasl_handler_get_channel (EmpathyServerSASLHandler *handler)
+{
+ EmpathyServerSASLHandlerPriv *priv;
+
+ g_return_val_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (handler), NULL);
+
+ priv = handler->priv;
+
+ return priv->channel;
+}
+
+gboolean
+empathy_server_sasl_handler_has_password (EmpathyServerSASLHandler *handler)
+{
+ EmpathyServerSASLHandlerPriv *priv;
+
+ g_return_val_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (handler), FALSE);
+
+ priv = handler->priv;
+
+ return (priv->password != NULL);
+}
+
+/**
+ * empathy_server_sasl_handler_can_save_response_somewhere:
+ * @self:
+ *
+ * Returns: %TRUE if the response can be saved somewhere, either the keyring
+ * or via Ch.I.CredentialsStorage
+ */
+gboolean
+empathy_server_sasl_handler_can_save_response_somewhere (
+ EmpathyServerSASLHandler *self)
+{
+ EmpathyServerSASLHandlerPriv *priv;
+ gboolean may_save_response;
+ gboolean has_storage_iface;
+
+ g_return_val_if_fail (EMPATHY_IS_SERVER_SASL_HANDLER (self), FALSE);
+
+ priv = self->priv;
+
+ may_save_response = channel_has_may_save_response (priv->channel);
+
+ has_storage_iface = tp_proxy_has_interface_by_id (priv->channel,
+ EMP_IFACE_QUARK_CHANNEL_INTERFACE_CREDENTIALS_STORAGE);
+
+ return may_save_response || has_storage_iface;
+}
projects / empathy.git / blobdiff