void
tpaw_keyring_set_room_password_async (TpAccount *account,
const gchar *id,
const gchar *password,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
gchar *name;
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (id != NULL);
g_return_if_fail (password != NULL);
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, tpaw_keyring_set_room_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Remembering password for room '%s' on account '%s'", id, account_id);
name = g_strdup_printf (_("Password for chatroom “%s” on account %s (%s)"),
id, tp_account_get_display_name (account), account_id);
secret_password_store (&room_keyring_schema, NULL, name, password,
NULL, store_password_cb, simple,
"account-id", account_id,
"room-id", id,
NULL);
g_free (name);
}
void
empathy_keyring_set_account_password_async (TpAccount *account,
const gchar *password,
gboolean remember,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
gchar *name;
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (password != NULL);
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, empathy_keyring_set_account_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Remembering password for %s", account_id);
const gchar *provider;
provider = tp_account_get_storage_provider (account);
if (!tp_strdiff (provider, EMPATHY_UOA_PROVIDER))
{
uoa_set_account_password (account, password, remember, simple);
g_object_unref (simple);
return;
}
g_object_unref(simple);
}
void
tpaw_keyring_get_room_password_async (TpAccount *account,
const gchar *id,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (id != NULL);
g_return_if_fail (callback != NULL);
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, tpaw_keyring_get_room_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Trying to get password for room '%s' on account '%s'",
id, account_id);
secret_password_lookup (&room_keyring_schema, NULL,
lookup_item_cb, simple,
"account-id", account_id,
"room-id", id,
NULL);
}
void
empathy_keyring_delete_account_password_async (TpAccount *account,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
g_return_if_fail (TP_IS_ACCOUNT (account));
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, empathy_keyring_delete_account_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Deleting password for %s", account_id);
const gchar *provider;
provider = tp_account_get_storage_provider (account);
if (!tp_strdiff (provider, EMPATHY_UOA_PROVIDER))
{
/* I see no other way to forget the stored password than overwriting
* with an empty one. */
uoa_set_account_password (account, "", FALSE, simple);
g_object_unref (simple);
return;
}
g_object_unref(simple);
}
void
empathy_uoa_auth_handler_start (EmpathyUoaAuthHandler *self,
TpChannel *channel,
TpAccount *tp_account)
{
const GValue *id_value;
AgAccountId id;
AgAccount *account;
GList *l = NULL;
AgAccountService *service;
AuthContext *ctx;
g_return_if_fail (TP_IS_CHANNEL (channel));
g_return_if_fail (TP_IS_ACCOUNT (tp_account));
g_return_if_fail (empathy_uoa_auth_handler_supports (self, channel,
tp_account));
DEBUG ("Start UOA auth for account: %s",
tp_proxy_get_object_path (tp_account));
id_value = tp_account_get_storage_identifier (tp_account);
id = g_value_get_uint (id_value);
account = ag_manager_get_account (self->priv->manager, id);
if (account != NULL)
l = ag_account_list_services_by_type (account, TPAW_UOA_SERVICE_TYPE);
if (l == NULL)
{
DEBUG ("Couldn't find IM service for AgAccountId %u", id);
g_object_unref (account);
tp_channel_close_async (channel, NULL, NULL);
return;
}
/* Assume there is only one IM service */
service = ag_account_service_new (account, l->data);
ag_service_list_free (l);
g_object_unref (account);
ctx = auth_context_new (channel, service);
if (ctx->session == NULL)
{
/* This (usually?) means we never stored credentials for this account.
* To ask user to type his password SSO needs a SignonIdentity bound to
* our account. Let's store an empty password. */
DEBUG ("Couldn't create a signon session");
tpaw_keyring_set_account_password_async (tp_account, "", FALSE,
set_account_password_cb, ctx);
}
else
{
/* All is fine! Query UOA for more info */
signon_identity_query_info (ctx->identity,
identity_query_info_cb, ctx);
}
g_object_unref (service);
}
GtkWidget *
tpaw_user_info_new (TpAccount *account)
{
g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
return g_object_new (TPAW_TYPE_USER_INFO,
"account", account,
NULL);
}
EmpathyTpStreamedMedia *
empathy_tp_streamed_media_new (TpAccount *account,
TpChannel *channel)
{
g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL);
return g_object_new (EMPATHY_TYPE_TP_STREAMED_MEDIA,
"account", account,
"channel", channel,
NULL);
}
void
tpaw_keyring_set_account_password_async (TpAccount *account,
const gchar *password,
gboolean remember,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
gchar *name;
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (password != NULL);
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, tpaw_keyring_set_account_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Remembering password for %s", account_id);
#ifdef HAVE_UOA
{
const gchar *provider;
provider = tp_account_get_storage_provider (account);
if (!tp_strdiff (provider, TPAW_UOA_PROVIDER))
{
uoa_set_account_password (account, password, remember, simple);
g_object_unref (simple);
return;
}
}
#endif
name = g_strdup_printf (_("IM account password for %s (%s)"),
tp_account_get_display_name (account), account_id);
secret_password_store (&account_keyring_schema,
remember ? NULL : SECRET_COLLECTION_SESSION,
name, password,
NULL, store_password_cb, simple,
"account-id", account_id,
"param-name", "password",
NULL);
g_free (name);
}
void
empathy_server_sasl_handler_new_async (TpAccount *account,
TpChannel *channel,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (TP_IS_CHANNEL (channel));
g_return_if_fail (callback != NULL);
g_async_initable_new_async (EMPATHY_TYPE_SERVER_SASL_HANDLER,
G_PRIORITY_DEFAULT, NULL, callback, user_data,
"account", account,
"channel", channel,
NULL);
}
void hev_impathy_server_sasl_handler_new_async(
TpAccount *account, TpChannel *channel,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_return_if_fail(TP_IS_ACCOUNT(account));
g_return_if_fail(TP_IS_CHANNEL(channel));
g_return_if_fail(NULL!=callback);
g_async_initable_new_async(HEV_TYPE_IMPATHY_SERVER_SASL_HANDLER,
G_PRIORITY_DEFAULT, NULL, callback, user_data,
"account", account, "channel", channel,
NULL);
}
/**
* tp_yts_status_ensure_async:
* @account: The Ytstenut enabled account
* @cancellable: Not used
* @callback: A callback which should be called when the result is ready
* @user_data: Data to pass to the callback
*
* Create a #TpYtsStatus object for a Ytstenut enabled
* connection. @account must be either connected, or in the process of
* connecting. Calling tp_yts_account_manager_hold() before this
* function (even if haven't re-entered the mainloop yet) is
* acceptable for connecting the account.
*/
void
tp_yts_status_ensure_async (TpAccount *account,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
TpConnection *connection;
g_return_if_fail (TP_IS_ACCOUNT (account));
connection = tp_account_get_connection (account);
res = g_simple_async_result_new (G_OBJECT (account), callback, user_data,
tp_yts_status_ensure_async);
if (connection == NULL)
{
if (tp_account_get_changing_presence (account))
{
/* just wait for the connection */
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (on_account_notify_connection), res, 0);
}
else
{
/* wait to see if the connection appears */
ChangingPresenceData *data = g_slice_new0 (ChangingPresenceData);
data->res = res;
data->account = account;
data->source_id = g_timeout_add_seconds (1, on_account_timeout, data);
data->handler_id = g_signal_connect (account,
"notify::changing-presence",
G_CALLBACK (on_account_notify_changing_presence),
data);
}
}
else
{
_tp_yts_connection_future_ensure_sidecar_async (connection,
TP_YTS_IFACE_STATUS, cancellable,
on_connection_future_ensure_sidecar_returned, res);
}
}
/**
* tp_yts_status_ensure_finish:
* @account: The Ytstenut enabled account
* @result: The result object passed to the callback
* @error: If an error occurred, this will be set
*
* Complete an asynchronous operation to create a #TpYtsStatus object.
*
* Returns: A new #TpYtsStatus proxy, which you can use to access
* the Ytstenut Status service. If the operation failed, %NULL will be returned.
*/
TpYtsStatus *
tp_yts_status_ensure_finish (TpAccount *account,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *res;
g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
res = G_SIMPLE_ASYNC_RESULT (result);
g_return_val_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (account), tp_yts_status_ensure_async), NULL);
if (g_simple_async_result_propagate_error (res, error))
return NULL;
return g_object_ref (g_simple_async_result_get_op_res_gpointer (res));
}
/**
* empathy_ft_handler_new_outgoing:
* @account: the #TpAccount to send @source to
* @contact: the #TpContact to send @source to
* @source: the #GFile to send
* @callback: callback to be called when the handler has been created
* @user_data: user data to be passed to @callback
*
* Triggers the creation of a new #EmpathyFTHandler for an outgoing transfer.
*/
void
empathy_ft_handler_new_outgoing (
TpAccount *account,
TpContact *contact,
GFile *source,
gint64 action_time,
EmpathyFTHandlerReadyCallback callback,
gpointer user_data)
{
EmpathyFTHandler *handler;
CallbacksData *data;
EmpathyFTHandlerPriv *priv;
DEBUG ("New handler outgoing");
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (TP_IS_CONTACT (contact));
g_return_if_fail (G_IS_FILE (source));
handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
"account", account,
"contact", contact,
"gfile", source,
"user-action-time", action_time,
NULL);
priv = handler->priv;
data = g_slice_new0 (CallbacksData);
data->callback = callback;
data->user_data = user_data;
data->handler = g_object_ref (handler);
/* start collecting info about the file */
g_file_query_info_async (priv->gfile,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_SIZE ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
NULL, (GAsyncReadyCallback) ft_handler_gfile_ready_cb, data);
}
static void hev_impathy_server_sasl_handler_init_async(GAsyncInitable *initable,
gint io_priority, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
HevImpathyServerSASLHandler *self = HEV_IMPATHY_SERVER_SASL_HANDLER(initable);
HevImpathyServerSASLHandlerPrivate *priv =
HEV_IMPATHY_SERVER_SASL_HANDLER_GET_PRIVATE(self);
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
g_return_if_fail(TP_IS_ACCOUNT(priv->account));
priv->async_init_res = g_simple_async_result_new(G_OBJECT(self),
callback, user_data,
hev_impathy_server_sasl_handler_new_async);
hev_impathy_keyring_get_account_password_async(priv->account,
hev_impathy_server_sasl_handler_get_password_async_handler,
self);
}
void
tpaw_keyring_delete_account_password_async (TpAccount *account,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
g_return_if_fail (TP_IS_ACCOUNT (account));
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, tpaw_keyring_delete_account_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Deleting password for %s", account_id);
#ifdef HAVE_UOA
{
const gchar *provider;
provider = tp_account_get_storage_provider (account);
if (!tp_strdiff (provider, TPAW_UOA_PROVIDER))
{
/* I see no other way to forget the stored password than overwriting
* with an empty one. */
uoa_set_account_password (account, "", FALSE, simple);
g_object_unref (simple);
return;
}
}
#endif
secret_password_clear (&account_keyring_schema, NULL,
items_delete_cb, simple,
"account-id", account_id,
"param-name", "password",
NULL);
}
void
tpaw_keyring_get_account_password_async (TpAccount *account,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
const gchar *account_id;
g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (callback != NULL);
simple = g_simple_async_result_new (G_OBJECT (account), callback,
user_data, tpaw_keyring_get_account_password_async);
account_id = tp_proxy_get_object_path (account) +
strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
DEBUG ("Trying to get password for: %s", account_id);
#ifdef HAVE_UOA
{
const gchar *provider;
provider = tp_account_get_storage_provider (account);
if (!tp_strdiff (provider, TPAW_UOA_PROVIDER))
{
uoa_get_account_password (account, simple);
g_object_unref (simple);
return;
}
}
#endif
secret_password_lookup (&account_keyring_schema, NULL,
lookup_item_cb, simple,
"account-id", account_id,
"param-name", "password",
NULL);
}
gboolean
empathy_uoa_auth_handler_supports (EmpathyUoaAuthHandler *self,
TpChannel *channel,
TpAccount *account)
{
const gchar *provider;
EmpathySaslMechanism mech;
g_return_val_if_fail (TP_IS_CHANNEL (channel), FALSE);
g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE);
provider = tp_account_get_storage_provider (account);
if (tp_strdiff (provider, EMPATHY_UOA_PROVIDER))
return FALSE;
mech = empathy_sasl_channel_select_mechanism (channel);
return mech == EMPATHY_SASL_MECHANISM_FACEBOOK ||
mech == EMPATHY_SASL_MECHANISM_WLM ||
mech == EMPATHY_SASL_MECHANISM_GOOGLE ||
mech == EMPATHY_SASL_MECHANISM_PASSWORD;
}