static void remmina_file_editor_update_ssh(RemminaFileEditor* gfe)
{
RemminaFileEditorPriv* priv = gfe->priv;
gboolean ssh_enabled;
if (priv->ssh_charset_combo)
{
remmina_file_set_string_ref(priv->remmina_file, "ssh_charset",
remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->ssh_charset_combo)));
}
if (g_strcmp0(remmina_file_get_string(priv->remmina_file, "protocol"), "SFTP") == 0
|| g_strcmp0(remmina_file_get_string(priv->remmina_file, "protocol"), "SSH") == 0)
{
ssh_enabled = TRUE;
}
else
{
ssh_enabled = (priv->ssh_enabled_check ?
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->ssh_enabled_check)) : FALSE);
remmina_file_set_int(
priv->remmina_file,
"ssh_loopback",
(priv->ssh_loopback_check ?
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->ssh_loopback_check)) :
FALSE));
}
remmina_file_set_int(priv->remmina_file, "ssh_enabled", ssh_enabled);
remmina_file_set_string(priv->remmina_file, "ssh_username",
(ssh_enabled ? gtk_entry_get_text(GTK_ENTRY(priv->ssh_username_entry)) : NULL));
remmina_file_set_string(
priv->remmina_file,
"ssh_server",
(ssh_enabled && priv->ssh_server_entry
&& (priv->ssh_server_custom_radio == NULL
|| gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(priv->ssh_server_custom_radio))) ?
gtk_entry_get_text(GTK_ENTRY(priv->ssh_server_entry)) : NULL));
remmina_file_set_int(
priv->remmina_file,
"ssh_auth",
(priv->ssh_auth_publickey_radio
&& gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(priv->ssh_auth_publickey_radio)) ?
SSH_AUTH_PUBLICKEY :
priv->ssh_auth_auto_publickey_radio
&& gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(priv->ssh_auth_auto_publickey_radio)) ?
SSH_AUTH_AUTO_PUBLICKEY : SSH_AUTH_PASSWORD));
remmina_file_set_string(
priv->remmina_file,
"ssh_privatekey",
(priv->ssh_privatekey_chooser ?
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(priv->ssh_privatekey_chooser)) : NULL));
}
GtkWidget* remmina_file_editor_new_full(const gchar* server, const gchar* protocol)
{
RemminaFile* remminafile;
remminafile = remmina_file_new();
if (server)
remmina_file_set_string(remminafile, "server", server);
if (protocol)
remmina_file_set_string(remminafile, "protocol", protocol);
return remmina_file_editor_new_from_file(remminafile);
}
RemminaFile*
remmina_file_load(const gchar *filename)
{
GKeyFile *gkeyfile;
RemminaFile *remminafile;
gchar **keys;
gchar *key;
gint i;
gchar *s;
gboolean encrypted;
gkeyfile = g_key_file_new();
if (!g_key_file_load_from_file(gkeyfile, filename, G_KEY_FILE_NONE, NULL))
return NULL;
if (g_key_file_has_key(gkeyfile, "remmina", "name", NULL))
{
remminafile = remmina_file_new_empty();
remminafile->filename = g_strdup(filename);
keys = g_key_file_get_keys(gkeyfile, "remmina", NULL, NULL);
if (keys)
{
for (i = 0; keys[i]; i++)
{
key = keys[i];
encrypted = FALSE;
remmina_setting_get_group(key, &encrypted);
if (encrypted)
{
s = g_key_file_get_string(gkeyfile, "remmina", key, NULL);
if (g_strcmp0(s, ".") == 0)
{
remmina_file_set_string(remminafile, key, s);
}
else
{
remmina_file_set_string_ref(remminafile, key, remmina_crypt_decrypt(s));
}
g_free(s);
}
else
{
remmina_file_set_string_ref(remminafile, key,
g_key_file_get_string(gkeyfile, "remmina", key, NULL));
}
}
g_strfreev(keys);
}
}
else
{
remminafile = NULL;
}
g_key_file_free(gkeyfile);
return remminafile;
}
static void remmina_file_editor_update(RemminaFileEditor* gfe)
{
RemminaFileEditorPriv* priv = gfe->priv;
remmina_file_set_string(priv->remmina_file, "name", gtk_entry_get_text(GTK_ENTRY(priv->name_entry)));
remmina_file_set_string_ref(priv->remmina_file, "group",
(priv->group_combo ? remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->group_combo)) : NULL));
remmina_file_set_string_ref(priv->remmina_file, "protocol",
remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->protocol_combo)));
remmina_file_set_string_ref(priv->remmina_file, "server",
(priv->server_combo ? remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->server_combo)) : NULL));
remmina_file_set_string(priv->remmina_file, "password",
(priv->password_entry ? gtk_entry_get_text(GTK_ENTRY(priv->password_entry)) : NULL));
if (priv->resolution_auto_radio)
{
remmina_file_set_string_ref(
priv->remmina_file,
"resolution",
(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->resolution_auto_radio)) ?
NULL :
remmina_public_combo_get_active_text(
GTK_COMBO_BOX(priv->resolution_custom_combo))));
}
if (priv->keymap_combo)
{
remmina_file_set_string_ref(priv->remmina_file, "keymap",
remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->keymap_combo)));
}
if (priv->scaler_widget)
{
remmina_file_set_int(priv->remmina_file, "hscale", REMMINA_SCALER(priv->scaler_widget)->hscale);
remmina_file_set_int(priv->remmina_file, "vscale", REMMINA_SCALER(priv->scaler_widget)->vscale);
remmina_file_set_int(priv->remmina_file, "aspectscale", REMMINA_SCALER(priv->scaler_widget)->aspectscale);
}
remmina_file_editor_update_ssh(gfe);
remmina_file_editor_update_settings(gfe);
}
RemminaFile*
remmina_file_dup_temp_protocol(RemminaFile *remminafile, const gchar *new_protocol)
{
RemminaFile *tmp;
tmp = remmina_file_dup(remminafile);
g_free(tmp->filename);
tmp->filename = NULL;
remmina_file_set_string(tmp, "protocol", new_protocol);
return tmp;
}
static gboolean remmina_main_quickconnect(RemminaMain *remminamain)
{
RemminaFile* remminafile;
gint index;
gchar* server;
gchar* protocol;
remminafile = remmina_file_new();
server = strdup(gtk_entry_get_text(GTK_ENTRY(remminamain->priv->quickconnect_server)));
index = gtk_combo_box_get_active(GTK_COMBO_BOX(remminamain->priv->quickconnect_protocol));
switch (index)
{
case 0:
protocol = "RDP";
break;
case 1:
protocol = "VNC";
break;
case 2:
protocol = "NX";
break;
case 3:
protocol = "SSH";
break;
default:
protocol = "RDP";
break;
}
remmina_file_set_string(remminafile, "sound", "off");
remmina_file_set_string(remminafile, "server", server);
remmina_file_set_string(remminafile, "name", server);
remmina_file_set_string(remminafile, "protocol", protocol);
remmina_connection_window_open_from_file(remminafile);
return FALSE;
}
static void remmina_file_editor_update_settings(RemminaFileEditor* gfe)
{
RemminaFileEditorPriv* priv = gfe->priv;
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, priv->setting_widgets);
while (g_hash_table_iter_next(&iter, &key, &value))
{
if (GTK_IS_ENTRY(value))
{
remmina_file_set_string(priv->remmina_file, (gchar*) key, gtk_entry_get_text(GTK_ENTRY(value)));
}
else
if (GTK_IS_COMBO_BOX(value))
{
remmina_file_set_string_ref(priv->remmina_file, (gchar*) key,
remmina_public_combo_get_active_text(GTK_COMBO_BOX(value)));
}
else
if (GTK_IS_FILE_CHOOSER(value))
{
remmina_file_set_string(
priv->remmina_file,
(gchar*) key,
gtk_widget_get_sensitive(GTK_WIDGET(value)) ?
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(value)) :
NULL);
}
else
if (GTK_IS_TOGGLE_BUTTON(value))
{
remmina_file_set_int(priv->remmina_file, (gchar*) key,
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(value)));
}
}
}
static void remmina_file_editor_on_default(GtkWidget* button, RemminaFileEditor* gfe)
{
RemminaFile* gf;
GtkWidget* dialog;
remmina_file_editor_update(gfe);
gf = remmina_file_dup(gfe->priv->remmina_file);
remmina_file_set_filename(gf, remmina_pref_file);
/* Clear properties that should never be default */
remmina_file_set_string(gf, "name", NULL);
remmina_file_set_string(gf, "server", NULL);
remmina_file_set_string(gf, "password", NULL);
remmina_file_save_all(gf);
remmina_file_free(gf);
dialog = gtk_message_dialog_new(GTK_WINDOW(gfe), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
_("Default settings saved."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
RemminaFile*
remmina_file_dup(RemminaFile *remminafile)
{
RemminaFile *dupfile;
GHashTableIter iter;
const gchar *key, *value;
dupfile = remmina_file_new_empty();
dupfile->filename = g_strdup(remminafile->filename);
g_hash_table_iter_init(&iter, remminafile->settings);
while (g_hash_table_iter_next(&iter, (gpointer*) &key, (gpointer*) &value))
{
remmina_file_set_string(dupfile, key, value);
}
return dupfile;
}
static void remmina_file_editor_create_ssh_privatekey(RemminaFileEditor* gfe, GtkWidget* table, gint row, gint column)
{
gchar* s;
GtkWidget* widget;
GtkWidget* dialog;
const gchar* ssh_privatekey;
RemminaFileEditorPriv* priv = gfe->priv;
widget = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(priv->ssh_auth_password_radio), _("Identity file"));
g_signal_connect(G_OBJECT(widget), "toggled",
G_CALLBACK(remmina_file_editor_ssh_auth_publickey_radio_on_toggled), gfe);
priv->ssh_auth_publickey_radio = widget;
gtk_widget_show(widget);
gtk_table_attach(GTK_TABLE(table), widget, column, column + 1, row, row + 1, GTK_FILL, 0, 0, 0);
dialog = gtk_file_chooser_dialog_new (_("Identity file"), GTK_WINDOW(gfe), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
widget = gtk_file_chooser_button_new_with_dialog (dialog);
s = g_strdup_printf("%s/.ssh", g_get_home_dir ());
if (g_file_test (s, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), s);
}
g_free(s);
gtk_widget_show(widget);
gtk_table_attach_defaults (GTK_TABLE(table), widget, column + 1, column + 2, row, row + 1);
priv->ssh_privatekey_chooser = widget;
ssh_privatekey = remmina_file_get_string (priv->remmina_file, "ssh_privatekey");
if (ssh_privatekey &&
g_file_test (ssh_privatekey, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_EXISTS))
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (priv->ssh_privatekey_chooser),
ssh_privatekey);
}
else
{
remmina_file_set_string (priv->remmina_file, "ssh_privatekey", NULL);
}
}
static void remmina_file_editor_on_connect(GtkWidget* button, RemminaFileEditor* gfe)
{
RemminaFile* gf;
remmina_file_editor_update(gfe);
if (remmina_pref.save_when_connect)
{
remmina_file_save_all(gfe->priv->remmina_file);
remmina_icon_populate_menu();
}
gf = remmina_file_dup(gfe->priv->remmina_file);
/* Put server into name for Quick Connect */
if (remmina_file_get_filename(gf) == NULL)
{
remmina_file_set_string(gf, "name", remmina_file_get_string(gf, "server"));
}
gtk_widget_destroy(GTK_WIDGET(gfe));
remmina_connection_window_open_from_file(gf);
}
