/**
* spice_set_session_option:
* @session: a #SpiceSession to set option upon
*
* Set various properties on @session, according to the commandline
* arguments given to spice_get_option_group() option group.
**/
void spice_set_session_option(SpiceSession *session)
{
g_return_if_fail(SPICE_IS_SESSION(session));
if (ca_file == NULL) {
const char *homedir = g_getenv("HOME");
if (!homedir)
homedir = g_get_home_dir();
ca_file = g_strdup_printf("%s/.spicec/spice_truststore.pem", homedir);
}
if (disable_effects) {
GStrv effects;
effects = g_strsplit(disable_effects, ",", -1);
if (effects)
g_object_set(session, "disable-effects", effects, NULL);
g_strfreev(effects);
}
if (color_depth)
g_object_set(session, "color-depth", color_depth, NULL);
if (ca_file)
g_object_set(session, "ca-file", ca_file, NULL);
if (host_subject)
g_object_set(session, "cert-subject", host_subject, NULL);
if (smartcard) {
g_object_set(session, "enable-smartcard", smartcard, NULL);
if (smartcard_certificates) {
GStrv certs_strv;
certs_strv = g_strsplit(smartcard_certificates, ",", -1);
if (certs_strv)
g_object_set(session, "smartcard-certificates", certs_strv, NULL);
g_strfreev(certs_strv);
}
if (smartcard_db)
g_object_set(session, "smartcard-db", smartcard_db, NULL);
}
if (usbredir_auto_redirect_filter) {
SpiceUsbDeviceManager *m = spice_usb_device_manager_get(session, NULL);
if (m)
g_object_set(m, "auto-connect-filter",
usbredir_auto_redirect_filter, NULL);
}
if (usbredir_redirect_on_connect) {
SpiceUsbDeviceManager *m = spice_usb_device_manager_get(session, NULL);
if (m)
g_object_set(m, "redirect-on-connect",
usbredir_redirect_on_connect, NULL);
}
if (disable_usbredir)
g_object_set(session, "enable-usbredir", FALSE, NULL);
if (disable_audio)
g_object_set(session, "enable-audio", FALSE, NULL);
if (cache_size)
g_object_set(session, "cache-size", cache_size, NULL);
if (glz_window_size)
g_object_set(session, "glz-window-size", glz_window_size, NULL);
}
spice_connection *connection_new(void)
{
spice_connection *conn;
SpiceUsbDeviceManager *manager;
conn = g_new0(spice_connection, 1);
conn->session = spice_session_new();
//conn->gtk_session = spice_gtk_session_get(conn->session);
g_signal_connect(conn->session, "channel-new",
G_CALLBACK(channel_new), conn);
g_signal_connect(conn->session, "channel-destroy",
G_CALLBACK(channel_destroy), conn);
g_signal_connect(conn->session, "notify::migration-state",
G_CALLBACK(migration_state), conn);
manager = spice_usb_device_manager_get(conn->session, NULL);
if (manager) {
g_signal_connect(manager, "auto-connect-failed",
G_CALLBACK(usb_auto_connect_failed), NULL);
g_signal_connect(manager, "device-error",
G_CALLBACK(usb_device_error), NULL);
g_signal_connect(manager, "device-added",
G_CALLBACK(usb_device_added), NULL);
g_signal_connect(manager, "device-removed",
G_CALLBACK(usb_device_removed), NULL);
}
connections++;
SPICE_DEBUG("%s (%d)", __FUNCTION__, connections);
return conn;
}
static GObject *spice_usb_device_widget_constructor(
GType gtype, guint n_properties, GObjectConstructParam *properties)
{
GObject *obj;
SpiceUsbDeviceWidget *self;
SpiceUsbDeviceWidgetPrivate *priv;
GPtrArray *devices = NULL;
GError *err = NULL;
GtkWidget *label;
gchar *str;
int i;
{
/* Always chain up to the parent constructor */
GObjectClass *parent_class;
parent_class = G_OBJECT_CLASS(spice_usb_device_widget_parent_class);
obj = parent_class->constructor(gtype, n_properties, properties);
}
self = SPICE_USB_DEVICE_WIDGET(obj);
priv = self->priv;
if (!priv->session)
g_error("SpiceUsbDeviceWidget constructed without a session");
label = gtk_label_new(NULL);
str = g_strdup_printf("<b>%s</b>", _("Select USB devices to redirect"));
gtk_label_set_markup(GTK_LABEL (label), str);
g_free(str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(self), label, FALSE, FALSE, 0);
priv->manager = spice_usb_device_manager_get(priv->session, &err);
if (err) {
spice_usb_device_widget_show_info_bar(self, err->message,
GTK_MESSAGE_WARNING,
GTK_STOCK_DIALOG_WARNING);
g_clear_error(&err);
return obj;
}
g_signal_connect(priv->manager, "device-added",
G_CALLBACK(device_added_cb), self);
g_signal_connect(priv->manager, "device-removed",
G_CALLBACK(device_removed_cb), self);
g_signal_connect(priv->manager, "device-error",
G_CALLBACK(device_error_cb), self);
devices = spice_usb_device_manager_get_devices(priv->manager);
if (!devices)
goto end;
for (i = 0; i < devices->len; i++)
device_added_cb(NULL, g_ptr_array_index(devices, i), self);
g_ptr_array_unref(devices);
end:
return obj;
}
static void spice_gtk_session_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
SpiceGtkSession *self = SPICE_GTK_SESSION(gobject);
SpiceGtkSessionPrivate *s = self->priv;
switch (prop_id) {
case PROP_SESSION:
s->session = g_value_get_object(value);
break;
case PROP_AUTO_CLIPBOARD:
s->auto_clipboard_enable = g_value_get_boolean(value);
break;
case PROP_AUTO_USBREDIR: {
SpiceDesktopIntegration *desktop_int;
gboolean orig_value = s->auto_usbredir_enable;
s->auto_usbredir_enable = g_value_get_boolean(value);
if (s->auto_usbredir_enable == orig_value)
break;
if (s->auto_usbredir_reqs) {
SpiceUsbDeviceManager *manager =
spice_usb_device_manager_get(s->session, NULL);
if (!manager)
break;
g_object_set(manager, "auto-connect", s->auto_usbredir_enable,
NULL);
desktop_int = spice_desktop_integration_get(s->session);
if (s->auto_usbredir_enable)
spice_desktop_integration_inhibit_automount(desktop_int);
else
spice_desktop_integration_uninhibit_automount(desktop_int);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, pspec);
break;
}
}
/* private functions (usbredir related) */
G_GNUC_INTERNAL
void spice_gtk_session_request_auto_usbredir(SpiceGtkSession *self,
gboolean state)
{
g_return_if_fail(SPICE_IS_GTK_SESSION(self));
SpiceGtkSessionPrivate *s = self->priv;
SpiceDesktopIntegration *desktop_int;
SpiceUsbDeviceManager *manager;
if (state) {
s->auto_usbredir_reqs++;
if (s->auto_usbredir_reqs != 1)
return;
} else {
g_return_if_fail(s->auto_usbredir_reqs > 0);
s->auto_usbredir_reqs--;
if (s->auto_usbredir_reqs != 0)
return;
}
if (!s->auto_usbredir_enable)
return;
manager = spice_usb_device_manager_get(s->session, NULL);
if (!manager)
return;
g_object_set(manager, "auto-connect", state, NULL);
desktop_int = spice_desktop_integration_get(s->session);
if (state)
spice_desktop_integration_inhibit_automount(desktop_int);
else
spice_desktop_integration_uninhibit_automount(desktop_int);
}
static void channel_new(SpiceSession *s, SpiceChannel *channel, gpointer data)
{
spice_connection *conn = data;
int id;
g_object_get(channel, "channel-id", &id, NULL);
conn->channels++;
SPICE_DEBUG("new channel (#%d)", id);
if (SPICE_IS_MAIN_CHANNEL(channel)) {
SPICE_DEBUG("new main channel");
conn->main = SPICE_MAIN_CHANNEL(channel);
g_signal_connect(channel, "channel-event",
G_CALLBACK(main_channel_event), conn);
//g_signal_connect(channel, "main-mouse-update",
// G_CALLBACK(main_mouse_update), conn);
//g_signal_connect(channel, "main-agent-update",
// G_CALLBACK(main_agent_update), conn);
//main_mouse_update(channel, conn);
//main_agent_update(channel, conn);
}
if (SPICE_IS_DISPLAY_CHANNEL(channel)) {
if (id >= SPICE_N_ELEMENTS(conn->wins))
return;
if (conn->wins[id] != NULL)
return;
SPICE_DEBUG("new display channel (#%d)", id);
conn->wins[id] = create_spice_window(conn, channel, id);
//g_signal_connect(channel, "display-mark",
// G_CALLBACK(display_mark), conn->wins[id]);
//update_auto_usbredir_sensitive(conn);
}
if (SPICE_IS_INPUTS_CHANNEL(channel)) {
SPICE_DEBUG("new inputs channel");
//g_signal_connect(channel, "inputs-modifiers",
// G_CALLBACK(inputs_modifiers), conn);
}
if (soundEnabled && SPICE_IS_PLAYBACK_CHANNEL(channel)) {
SPICE_DEBUG("new audio channel");
conn->audio = spice_audio_get(s, NULL);
}
if (SPICE_IS_USBREDIR_CHANNEL(channel)) {
__android_log_write(ANDROID_LOG_INFO, "android-spice", "Created USB channel, attempting to add devices");
SpiceUsbDeviceManager *manager = spice_usb_device_manager_get(s, NULL);
GPtrArray *devices = spice_usb_device_manager_get_devices(manager);
if (devices) {
for (int i = 0; i < devices->len; i++) {
__android_log_write(ANDROID_LOG_INFO, "android-spicy", "Devices found, connecting...");
usb_device_added(manager, g_ptr_array_index(devices, i), NULL);
}
g_ptr_array_unref(devices);
}
}
//if (SPICE_IS_PORT_CHANNEL(channel)) {
// g_signal_connect(channel, "notify::port-opened",
// G_CALLBACK(port_opened), conn);
// g_signal_connect(channel, "port-data",
// G_CALLBACK(port_data), conn);
// spice_channel_connect(channel);
//}
}
