diff options
Diffstat (limited to 'plugins/telepathy/telepathy_channel_handler.c')
| -rw-r--r-- | plugins/telepathy/telepathy_channel_handler.c | 373 |
1 files changed, 373 insertions, 0 deletions
diff --git a/plugins/telepathy/telepathy_channel_handler.c b/plugins/telepathy/telepathy_channel_handler.c new file mode 100644 index 0000000..b690d97 --- /dev/null +++ b/plugins/telepathy/telepathy_channel_handler.c @@ -0,0 +1,373 @@ +/* + * Remmina - The GTK+ Remote Desktop Client + * Copyright (C) 2010 Vic Lee + * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo + * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * In addition, as a special exception, the copyright holders give + * permission to link the code of portions of this program with the + * OpenSSL library under certain conditions as described in each + * individual source file, and distribute linked combinations + * including the two. + * You must obey the GNU General Public License in all respects + * for all of the code used other than OpenSSL. * If you modify + * file(s) with this exception, you may extend this exception to your + * version of the file(s), but you are not obligated to do so. * If you + * do not wish to do so, delete this exception statement from your + * version. * If you delete this exception statement from all source + * files in the program, then also delete it here. + * + */ + +#include "common/remmina_plugin.h" +#include <telepathy-glib/account.h> +#include <telepathy-glib/channel.h> +#include <telepathy-glib/contact.h> +#include <telepathy-glib/dbus.h> +#include <telepathy-glib/defs.h> +#include <telepathy-glib/handle.h> +#include <telepathy-glib/interfaces.h> +#include <telepathy-glib/svc-client.h> +#include <telepathy-glib/util.h> +#include "telepathy_channel_handler.h" + +extern RemminaPluginService *remmina_plugin_telepathy_service; + +typedef struct _RemminaTpChannelHandler { + gchar *connection_path; + gchar *channel_path; + GHashTable *channel_properties; + DBusGMethodInvocation *context; + + GtkWidget *proto_widget; + guint disconnect_handler; + + TpDBusDaemon *bus; + TpAccount *account; + TpConnection *connection; + TpChannel *channel; + + gchar *alias; + gchar *host; + guint port; + gchar *protocol; +} RemminaTpChannelHandler; + +static void remmina_tp_channel_handler_free(RemminaTpChannelHandler *chandler) +{ + TRACE_CALL(__func__); + if (chandler->disconnect_handler) { + g_signal_handler_disconnect(chandler->proto_widget, chandler->disconnect_handler); + chandler->disconnect_handler = 0; + } + g_free(chandler->connection_path); + g_free(chandler->channel_path); + g_hash_table_destroy(chandler->channel_properties); + if (chandler->bus) { + g_object_unref(chandler->bus); + } + if (chandler->account) { + g_object_unref(chandler->account); + } + if (chandler->connection) { + g_object_unref(chandler->connection); + } + if (chandler->channel) { + g_object_unref(chandler->channel); + } + if (chandler->alias) { + g_free(chandler->alias); + } + if (chandler->host) { + g_free(chandler->host); + } + if (chandler->protocol) { + g_free(chandler->protocol); + } + g_free(chandler); +} + +static void remmina_tp_channel_handler_channel_closed(TpChannel *channel, gpointer user_data, GObject *self) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + + g_print("%s: %s\n", __func__, chandler->channel_path); + remmina_tp_channel_handler_free(chandler); +} + +static void remmina_tp_channel_handler_on_disconnect(GtkWidget *widget, RemminaTpChannelHandler *chandler) +{ + TRACE_CALL(__func__); + g_print("%s: %s\n", __func__, chandler->channel_path); + g_signal_handler_disconnect(widget, chandler->disconnect_handler); + chandler->disconnect_handler = 0; + tp_cli_channel_call_close(chandler->channel, -1, NULL, NULL, NULL, NULL); +} + +static void remmina_tp_channel_handler_connect(RemminaTpChannelHandler *chandler) +{ + TRACE_CALL(__func__); + RemminaFile *remminafile; + gchar *s; + + remminafile = remmina_plugin_telepathy_service->file_new(); + remmina_plugin_telepathy_service->file_set_string(remminafile, "name", chandler->alias); + remmina_plugin_telepathy_service->file_set_string(remminafile, "protocol", chandler->protocol); + s = g_strdup_printf("[%s]:%i", chandler->host, chandler->port); + remmina_plugin_telepathy_service->file_set_string(remminafile, "server", s); + g_free(s); + remmina_plugin_telepathy_service->file_set_int(remminafile, "colordepth", 8); + + g_free(chandler->alias); + chandler->alias = NULL; + g_free(chandler->protocol); + chandler->protocol = NULL; + + chandler->proto_widget = remmina_plugin_telepathy_service->open_connection(remminafile, + G_CALLBACK(remmina_tp_channel_handler_on_disconnect), chandler, &chandler->disconnect_handler); +} + +static void remmina_tp_channel_handler_get_service(TpProxy *channel, const GValue *service, const GError *error, + gpointer user_data, GObject *weak_object) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + const gchar *svc; + + if (error != NULL) { + g_print("%s: %s", __func__, error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + svc = g_value_get_string(service); + g_print("%s: %s %s:%u\n", __func__, svc, chandler->host, chandler->port); + + if (g_strcmp0(svc, "rfb") == 0) { + chandler->protocol = g_strdup("VNC"); + }else { + chandler->protocol = g_ascii_strup(svc, -1); + } + remmina_tp_channel_handler_connect(chandler); +} + +static void remmina_tp_channel_handler_accept(TpChannel *channel, const GValue *address, const GError *error, + gpointer user_data, GObject *weak_object) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + + if (error != NULL) { + g_print("%s: %s", __func__, error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + + dbus_g_type_struct_get(address, 0, &chandler->host, 1, &chandler->port, G_MAXUINT); + + tp_cli_dbus_properties_call_get(channel, -1, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE, "Service", + remmina_tp_channel_handler_get_service, chandler, NULL, NULL); +} + +static void remmina_tp_channel_handler_on_response(GtkDialog *dialog, gint response_id, RemminaTpChannelHandler *chandler) +{ + TRACE_CALL(__func__); + GValue noop = + { 0 }; + GError *error; + + if (response_id == GTK_RESPONSE_YES) { + g_value_init(&noop, G_TYPE_INT); + tp_cli_channel_type_stream_tube_call_accept(chandler->channel, -1, TP_SOCKET_ADDRESS_TYPE_IPV4, + TP_SOCKET_ACCESS_CONTROL_LOCALHOST, &noop, remmina_tp_channel_handler_accept, chandler, NULL, + NULL); + g_value_unset(&noop); + tp_svc_client_handler_return_from_handle_channels(chandler->context); + }else { + error = g_error_new(TP_ERROR, TP_ERROR_NOT_AVAILABLE, "Channel rejected by user."); + dbus_g_method_return_error(chandler->context, error); + g_error_free(error); + remmina_tp_channel_handler_free(chandler); + } +} + +static void remmina_tp_channel_handler_get_contacts(TpConnection *connection, guint n_contacts, TpContact * const *contacts, + guint n_failed, const TpHandle *failed, const GError *error, gpointer user_data, GObject *weak_object) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + TpContact *contact; + gchar *token; + const gchar *cm; + const gchar *protocol; + gchar *filename; + GdkPixbuf *pixbuf; + GtkWidget *image; + GtkWidget *dialog; + + if (error != NULL) { + g_print("%s: %s", __func__, error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + if (n_contacts <= 0) { + g_print("%s: no contacts\n", __func__); + remmina_tp_channel_handler_free(chandler); + return; + } + contact = contacts[0]; + chandler->alias = g_strdup(tp_contact_get_alias(contact)); + + dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, + _("%s wants to share their desktop.\nDo you accept?"), chandler->alias); + g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(remmina_tp_channel_handler_on_response), chandler); + g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL); + gtk_window_set_title(GTK_WINDOW(dialog), _("Desktop sharing invitation")); + remmina_plugin_telepathy_service->ui_register(dialog); + gtk_widget_show(dialog); + + token = (gchar*)tp_contact_get_avatar_token(contact); + if (token == NULL) { + return; + } + protocol = tp_connection_get_protocol_name(chandler->connection); + cm = tp_connection_get_cm_name(chandler->connection); + if (!protocol || !cm) { + return; + } + token = tp_escape_as_identifier(token); + filename = g_build_filename(g_get_user_cache_dir(), "telepathy", "avatars", cm, protocol, token, NULL); + g_free(token); + if (g_file_test(filename, G_FILE_TEST_EXISTS)) { + pixbuf = gdk_pixbuf_new_from_file(filename, NULL); + if (pixbuf) { + image = gtk_image_new_from_pixbuf(pixbuf); + gtk_widget_show(image); + g_object_unref(pixbuf); + gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(dialog), image); + } + } + g_free(filename); +} + +static void remmina_tp_channel_handler_channel_ready(TpChannel *channel, const GError *channel_error, gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + TpHandle handle; + GError *error = NULL; + TpContactFeature features[] = + { TP_CONTACT_FEATURE_ALIAS, TP_CONTACT_FEATURE_AVATAR_TOKEN }; + + if (channel_error != NULL) { + g_print("%s: %s\n", __func__, channel_error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + + if (tp_cli_channel_connect_to_closed(channel, remmina_tp_channel_handler_channel_closed, chandler, NULL, NULL, &error) + == NULL) { + g_print("tp_cli_channel_connect_to_closed: %s\n", channel_error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + g_print("%s: %s\n", __func__, chandler->channel_path); + + handle = tp_channel_get_handle(channel, NULL); + tp_connection_get_contacts_by_handle(chandler->connection, 1, &handle, G_N_ELEMENTS(features), features, + remmina_tp_channel_handler_get_contacts, chandler, NULL, NULL); +} + +static void remmina_tp_channel_handler_connection_ready(TpConnection *connection, const GError *connection_error, + gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + GError *error = NULL; + + if (connection_error != NULL) { + g_print("%s: %s\n", __func__, connection_error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + + chandler->channel = tp_channel_new_from_properties(connection, chandler->channel_path, chandler->channel_properties, + &error); + if (chandler->channel == NULL) { + g_print("tp_channel_new_from_properties: %s\n", error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + tp_channel_call_when_ready(chandler->channel, remmina_tp_channel_handler_channel_ready, chandler); +} + +static void remmina_tp_channel_handler_account_ready(GObject *account, GAsyncResult *res, gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler*)user_data; + GError *error = NULL; + + if (!tp_account_prepare_finish(TP_ACCOUNT(account), res, &error)) { + g_print("tp_account_prepare_finish: %s\n", error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + + chandler->connection = tp_connection_new(chandler->bus, NULL, chandler->connection_path, &error); + if (chandler->connection == NULL) { + g_print("tp_connection_new: %s\n", error->message); + remmina_tp_channel_handler_free(chandler); + return; + } + tp_connection_call_when_ready(chandler->connection, remmina_tp_channel_handler_connection_ready, chandler); +} + +void remmina_tp_channel_handler_new(const gchar *account_path, const gchar *connection_path, const gchar *channel_path, + GHashTable *channel_properties, DBusGMethodInvocation *context) +{ + TRACE_CALL(__func__); + TpDBusDaemon *bus; + TpAccount *account; + GError *error = NULL; + RemminaTpChannelHandler *chandler; + + bus = tp_dbus_daemon_dup(&error); + if (bus == NULL) { + g_print("tp_dbus_daemon_dup: %s", error->message); + return; + } + account = tp_account_new(bus, account_path, &error); + if (account == NULL) { + g_object_unref(bus); + g_print("tp_account_new: %s", error->message); + return; + } + + chandler = g_new0(RemminaTpChannelHandler, 1); + chandler->bus = bus; + chandler->account = account; + chandler->connection_path = g_strdup(connection_path); + chandler->channel_path = g_strdup(channel_path); + chandler->channel_properties = tp_asv_new(NULL, NULL); + tp_g_hash_table_update(chandler->channel_properties, channel_properties, (GBoxedCopyFunc)g_strdup, + (GBoxedCopyFunc)tp_g_value_slice_dup); + chandler->context = context; + + tp_account_prepare_async(account, NULL, remmina_tp_channel_handler_account_ready, chandler); +} + |