/*
* Virt Viewer: A virtual machine console viewer
*
* Copyright (C) 2007-2012 Red Hat, Inc.
* Copyright (C) 2009-2012 Daniel P. Berrange
* Copyright (C) 2010 Marc-André Lureau
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#include <config.h>
#include <locale.h>
#include <math.h>
#include "virt-viewer-session.h"
#include "virt-viewer-util.h"
#include "virt-viewer-display-vte.h"
typedef struct _VirtViewerSessionPrivate VirtViewerSessionPrivate;
struct _VirtViewerSessionPrivate
{
GList *displays;
VirtViewerApp *app;
gboolean auto_usbredir;
gboolean has_usbredir;
gchar *uri;
VirtViewerFile *file;
gboolean share_folder;
gchar *shared_folder;
gboolean share_folder_ro;
};
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(VirtViewerSession, virt_viewer_session, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_APP,
PROP_AUTO_USBREDIR,
PROP_HAS_USBREDIR,
PROP_FILE,
PROP_SW_SMARTCARD_READER,
PROP_SHARE_FOLDER,
PROP_SHARED_FOLDER,
PROP_SHARE_FOLDER_RO,
};
static void
virt_viewer_session_finalize(GObject *obj)
{
VirtViewerSession *session = VIRT_VIEWER_SESSION(obj);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(session);
GList *tmp = priv->displays;
while (tmp) {
g_object_unref(tmp->data);
tmp = tmp->next;
}
g_list_free(priv->displays);
g_free(priv->uri);
g_clear_object(&priv->file);
g_free(priv->shared_folder);
G_OBJECT_CLASS(virt_viewer_session_parent_class)->finalize(obj);
}
static void
virt_viewer_session_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
VirtViewerSession *self = VIRT_VIEWER_SESSION(object);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
switch (prop_id) {
case PROP_AUTO_USBREDIR:
virt_viewer_session_set_auto_usbredir(self, g_value_get_boolean(value));
break;
case PROP_HAS_USBREDIR:
priv->has_usbredir = g_value_get_boolean(value);
break;
case PROP_APP:
priv->app = g_value_get_object(value);
break;
case PROP_FILE:
virt_viewer_session_set_file(self, g_value_get_object(value));
break;
case PROP_SHARE_FOLDER:
priv->share_folder = g_value_get_boolean(value);
break;
case PROP_SHARED_FOLDER:
g_free(priv->shared_folder);
priv->shared_folder = g_value_dup_string(value);
break;
case PROP_SHARE_FOLDER_RO:
priv->share_folder_ro = g_value_get_boolean(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
virt_viewer_session_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
VirtViewerSession *self = VIRT_VIEWER_SESSION(object);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
switch (prop_id) {
case PROP_AUTO_USBREDIR:
g_value_set_boolean(value, virt_viewer_session_get_auto_usbredir(self));
break;
case PROP_HAS_USBREDIR:
g_value_set_boolean(value, priv->has_usbredir);
break;
case PROP_APP:
g_value_set_object(value, priv->app);
break;
case PROP_FILE:
g_value_set_object(value, priv->file);
break;
case PROP_SW_SMARTCARD_READER:
g_value_set_boolean(value, FALSE);
break;
case PROP_SHARE_FOLDER:
g_value_set_boolean(value, priv->share_folder);
break;
case PROP_SHARED_FOLDER:
g_value_set_string(value, priv->shared_folder);
break;
case PROP_SHARE_FOLDER_RO:
g_value_set_boolean(value, priv->share_folder_ro);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
virt_viewer_session_class_init(VirtViewerSessionClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS(class);
object_class->set_property = virt_viewer_session_set_property;
object_class->get_property = virt_viewer_session_get_property;
object_class->finalize = virt_viewer_session_finalize;
g_object_class_install_property(object_class,
PROP_AUTO_USBREDIR,
g_param_spec_boolean("auto-usbredir",
"USB redirection",
"USB redirection",
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_HAS_USBREDIR,
g_param_spec_boolean("has-usbredir",
"has USB redirection",
"has USB redirection",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_APP,
g_param_spec_object("app",
"VirtViewerApp",
"VirtViewerApp",
VIRT_VIEWER_TYPE_APP,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_FILE,
g_param_spec_object("file",
"VirtViewerFile",
"VirtViewerFile",
VIRT_VIEWER_TYPE_FILE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_SW_SMARTCARD_READER,
g_param_spec_boolean("software-smartcard-reader",
"Software smartcard reader",
"Indicates whether a software smartcard reader is available",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_SHARE_FOLDER,
g_param_spec_boolean("share-folder",
"Share folder",
"Indicates whether to share folder",
FALSE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_SHARED_FOLDER,
g_param_spec_string("shared-folder",
"Shared folder",
"Indicates the shared folder",
g_get_user_special_dir(G_USER_DIRECTORY_PUBLIC_SHARE),
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_SHARE_FOLDER_RO,
g_param_spec_boolean("share-folder-ro",
"Share folder read-only",
"Indicates whether to share folder in read-only",
FALSE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_signal_new("session-connected",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("session-initialized",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("session-disconnected",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("session-channel-open",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
g_signal_new("session-auth-refused",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("session-auth-unsupported",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("session-usb-failed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("session-display-added",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
VIRT_VIEWER_TYPE_DISPLAY);
g_signal_new("session-display-removed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
VIRT_VIEWER_TYPE_DISPLAY);
g_signal_new("session-display-updated",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("session-cut-text",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("session-bell",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("session-cancelled",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
}
static void
virt_viewer_session_init(VirtViewerSession *session G_GNUC_UNUSED)
{
}
static void
virt_viewer_session_on_monitor_geometry_changed(VirtViewerSession* self,
VirtViewerDisplay* display G_GNUC_UNUSED)
{
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
VirtViewerSessionClass *klass;
gboolean all_fullscreen = TRUE;
/* GHashTable<gint, GdkRectangle*> */
GHashTable *monitors;
gint n_sized_monitors = 0;
GList *l;
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (!klass->apply_monitor_geometry)
return;
monitors = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
for (l = priv->displays; l; l = l->next) {
VirtViewerDisplay *d = VIRT_VIEWER_DISPLAY(l->data);
if (VIRT_VIEWER_IS_DISPLAY_VTE(d))
continue;
guint nth = 0;
GdkRectangle *rect = g_new0(GdkRectangle, 1);
g_object_get(d, "nth-display", &nth, NULL);
virt_viewer_display_get_preferred_monitor_geometry(d, rect);
if (rect->width > 0 && rect->height > 0)
n_sized_monitors++;
if (virt_viewer_display_get_enabled(d) &&
!virt_viewer_display_get_fullscreen(d))
all_fullscreen = FALSE;
g_hash_table_insert(monitors, GINT_TO_POINTER(nth), rect);
}
if (n_sized_monitors == 0) {
goto cleanup;
}
if (!all_fullscreen)
virt_viewer_align_monitors_linear(monitors);
virt_viewer_shift_monitors_to_origin(monitors);
klass->apply_monitor_geometry(self, monitors);
cleanup:
g_hash_table_unref(monitors);
}
void virt_viewer_session_add_display(VirtViewerSession *session,
VirtViewerDisplay *display)
{
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(session);
if (g_list_find(priv->displays, display))
return;
priv->displays = g_list_append(priv->displays, display);
g_object_ref(display);
g_signal_emit_by_name(session, "session-display-added", display);
virt_viewer_signal_connect_object(display, "monitor-geometry-changed",
G_CALLBACK(virt_viewer_session_on_monitor_geometry_changed), session,
G_CONNECT_SWAPPED);
}
void virt_viewer_session_remove_display(VirtViewerSession *session,
VirtViewerDisplay *display)
{
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(session);
if (!g_list_find(priv->displays, display))
return;
priv->displays = g_list_remove(priv->displays, display);
g_signal_emit_by_name(session, "session-display-removed", display);
g_object_unref(display);
}
void virt_viewer_session_clear_displays(VirtViewerSession *session)
{
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(session);
GList *tmp = priv->displays;
while (tmp) {
VirtViewerDisplay *display = VIRT_VIEWER_DISPLAY(tmp->data);
g_signal_emit_by_name(session, "session-display-removed", display);
virt_viewer_display_close(display);
g_object_unref(display);
tmp = tmp->next;
}
g_list_free(priv->displays);
priv->displays = NULL;
}
void virt_viewer_session_update_displays_geometry(VirtViewerSession *session)
{
virt_viewer_session_on_monitor_geometry_changed(session, NULL);
}
void virt_viewer_session_close(VirtViewerSession *session)
{
g_return_if_fail(VIRT_VIEWER_IS_SESSION(session));
VIRT_VIEWER_SESSION_GET_CLASS(session)->close(session);
}
gboolean virt_viewer_session_open_fd(VirtViewerSession *session, int fd)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(session), FALSE);
return VIRT_VIEWER_SESSION_GET_CLASS(session)->open_fd(session, fd);
}
gboolean virt_viewer_session_open_host(VirtViewerSession *session, const gchar *host, const gchar *port, const gchar *tlsport)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(session), FALSE);
klass = VIRT_VIEWER_SESSION_GET_CLASS(session);
return klass->open_host(session, host, port, tlsport);
}
gboolean virt_viewer_session_open_uri(VirtViewerSession *session, const gchar *uri, GError **error)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(session), FALSE);
klass = VIRT_VIEWER_SESSION_GET_CLASS(session);
g_return_val_if_fail(klass->open_uri != NULL, FALSE);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(session);
priv->uri = g_strdup(uri);
return klass->open_uri(session, uri, error);
}
const gchar* virt_viewer_session_mime_type(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
if (priv->file)
return "application/x-virt-viewer";
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
g_return_val_if_fail(klass->mime_type != NULL, FALSE);
return klass->mime_type(self);
}
gboolean virt_viewer_session_channel_open_fd(VirtViewerSession *session,
VirtViewerSessionChannel *channel, int fd)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(session), FALSE);
return VIRT_VIEWER_SESSION_GET_CLASS(session)->channel_open_fd(session, channel, fd);
}
void virt_viewer_session_set_auto_usbredir(VirtViewerSession *self, gboolean auto_usbredir)
{
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
if (priv->auto_usbredir == auto_usbredir)
return;
priv->auto_usbredir = auto_usbredir;
g_object_notify(G_OBJECT(self), "auto-usbredir");
}
gboolean virt_viewer_session_get_auto_usbredir(VirtViewerSession *self)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
return priv->auto_usbredir;
}
void virt_viewer_session_set_has_usbredir(VirtViewerSession *self, gboolean has_usbredir)
{
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
if (priv->has_usbredir == has_usbredir)
return;
priv->has_usbredir = has_usbredir;
g_object_notify(G_OBJECT(self), "has-usbredir");
}
gboolean virt_viewer_session_get_has_usbredir(VirtViewerSession *self)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
return priv->has_usbredir;
}
void virt_viewer_session_usb_device_selection(VirtViewerSession *self,
GtkWindow *parent)
{
VirtViewerSessionClass *klass;
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
g_return_if_fail(klass->usb_device_selection != NULL);
klass->usb_device_selection(self, parent);
}
void virt_viewer_session_usb_device_reset(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (klass->usb_device_reset == NULL) {
g_debug("No session usbredir support");
return;
}
klass->usb_device_reset(self);
}
void virt_viewer_session_smartcard_insert(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (klass->smartcard_insert == NULL) {
g_debug("No session smartcard support");
return;
}
klass->smartcard_insert(self);
}
void virt_viewer_session_smartcard_remove(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (klass->smartcard_remove == NULL) {
g_debug("No session smartcard support");
return;
}
klass->smartcard_remove(self);
}
VirtViewerApp* virt_viewer_session_get_app(VirtViewerSession *self)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), NULL);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
return priv->app;
}
gchar* virt_viewer_session_get_uri(VirtViewerSession *self)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
return g_strdup(priv->uri);
}
void virt_viewer_session_set_file(VirtViewerSession *self, VirtViewerFile *file)
{
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
g_clear_object(&priv->file);
if (file)
priv->file = g_object_ref(file);
}
VirtViewerFile* virt_viewer_session_get_file(VirtViewerSession *self)
{
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), NULL);
VirtViewerSessionPrivate *priv = virt_viewer_session_get_instance_private(self);
return priv->file;
}
gboolean virt_viewer_session_can_share_folder(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
return klass->can_share_folder ? klass->can_share_folder(self) : FALSE;
}
gboolean virt_viewer_session_can_retry_auth(VirtViewerSession *self)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
return klass->can_retry_auth ? klass->can_retry_auth(self) : FALSE;
}
void virt_viewer_session_vm_action(VirtViewerSession *self, gint action)
{
VirtViewerSessionClass *klass;
g_return_if_fail(VIRT_VIEWER_IS_SESSION(self));
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (klass->vm_action)
klass->vm_action(self, action);
}
gboolean virt_viewer_session_has_vm_action(VirtViewerSession *self, gint action)
{
VirtViewerSessionClass *klass;
g_return_val_if_fail(VIRT_VIEWER_IS_SESSION(self), FALSE);
klass = VIRT_VIEWER_SESSION_GET_CLASS(self);
if (klass->has_vm_action)
return klass->has_vm_action(self, action);
return FALSE;
}