static void remmina_main_load_file_tree_callback(gpointer data, gpointer user_data)
{
RemminaMain *remminamain;
GtkTreeIter iter, child;
GtkTreeStore *store;
RemminaFile *remminafile;
gboolean found;
remminafile = (RemminaFile*) data;
remminamain = (RemminaMain*) user_data;
store = GTK_TREE_STORE(remminamain->priv->file_model);
found = FALSE;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
{
found = remmina_main_load_file_tree_find(GTK_TREE_MODEL(store), &iter,
remmina_file_get_string(remminafile, "group"));
}
gtk_tree_store_append(store, &child, (found ? &iter : NULL));
gtk_tree_store_set(store, &child, PROTOCOL_COLUMN, remmina_file_get_icon_name(remminafile), NAME_COLUMN,
remmina_file_get_string(remminafile, "name"), GROUP_COLUMN,
remmina_file_get_string(remminafile, "group"), SERVER_COLUMN,
remmina_file_get_string(remminafile, "server"), FILENAME_COLUMN, remmina_file_get_filename(remminafile),
-1);
}
gboolean
remmina_ssh_init_from_file (RemminaSSH *ssh, RemminaFile *remminafile)
{
const gchar *ssh_server;
const gchar *ssh_username;
const gchar *ssh_privatekey;
const gchar *server;
gchar *s;
ssh->session = NULL;
ssh->callback = NULL;
ssh->authenticated = FALSE;
ssh->error = NULL;
pthread_mutex_init (&ssh->ssh_mutex, NULL);
/* Parse the address and port */
ssh_server = remmina_file_get_string (remminafile, "ssh_server");
ssh_username = remmina_file_get_string (remminafile, "ssh_username");
ssh_privatekey = remmina_file_get_string (remminafile, "ssh_privatekey");
server = remmina_file_get_string (remminafile, "server");
if (ssh_server)
{
remmina_public_get_server_port (ssh_server, 22, &ssh->server, &ssh->port);
if (ssh->server[0] == '\0')
{
g_free(ssh->server);
remmina_public_get_server_port (server, 0, &ssh->server, NULL);
}
}
else if (server == NULL)
{
ssh->server = g_strdup ("localhost");
ssh->port = 22;
}
else
{
remmina_public_get_server_port (server, 0, &ssh->server, NULL);
ssh->port = 22;
}
ssh->user = g_strdup (ssh_username ? ssh_username : g_get_user_name ());
ssh->password = NULL;
ssh->auth = remmina_file_get_int (remminafile, "ssh_auth", 0);
ssh->charset = g_strdup (remmina_file_get_string (remminafile, "ssh_charset"));
/* Public/Private keys */
s = (ssh_privatekey ? g_strdup (ssh_privatekey) : remmina_ssh_find_identity ());
if (s)
{
ssh->privkeyfile = remmina_ssh_identity_path (s);
g_free(s);
}
else
{
ssh->privkeyfile = NULL;
}
return TRUE;
}
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));
}
void remmina_file_update_screen_resolution(RemminaFile *remminafile)
{
GdkScreen *screen;
gchar *pos;
gchar *resolution;
gint x, y;
gint monitor;
GdkRectangle rect;
resolution = g_strdup(remmina_file_get_string(remminafile, "resolution"));
if (resolution == NULL || strchr(resolution, 'x') == NULL)
{
gdk_display_get_pointer(gdk_display_get_default(), &screen, &x, &y, NULL);
monitor = gdk_screen_get_monitor_at_point(screen, x, y);
gdk_screen_get_monitor_geometry(screen, monitor, &rect);
remmina_file_set_int(remminafile, "resolution_width", rect.width);
remmina_file_set_int(remminafile, "resolution_height", rect.height);
}
else
{
pos = strchr(resolution, 'x');
*pos++ = '\0';
remmina_file_set_int(remminafile, "resolution_width", MAX(100, MIN(4096, atoi(resolution))));
remmina_file_set_int(remminafile, "resolution_height", MAX(100, MIN(4096, atoi(pos))));
}
g_free(resolution);
}
GNode* remmina_file_manager_get_group_tree(void)
{
gchar dirname[MAX_PATH_LEN];
gchar filename[MAX_PATH_LEN];
GDir* dir;
const gchar* name;
RemminaFile* remminafile;
const gchar* group;
GNode* root;
root = g_node_new(NULL);
g_snprintf(dirname, MAX_PATH_LEN, "%s/.remmina", g_get_home_dir());
dir = g_dir_open(dirname, 0, NULL);
if (dir == NULL)
return root;
while ((name = g_dir_read_name(dir)) != NULL)
{
if (!g_str_has_suffix(name, ".remmina"))
continue;
g_snprintf(filename, MAX_PATH_LEN, "%s/%s", dirname, name);
remminafile = remmina_file_load(filename);
group = remmina_file_get_string(remminafile, "group");
remmina_file_manager_add_group(root, group);
remmina_file_free(remminafile);
}
g_dir_close(dir);
return root;
}
static void remmina_main_load_file_list_callback(gpointer data, gpointer user_data)
{
RemminaMain *remminamain;
GtkTreeIter iter;
GtkListStore *store;
RemminaFile *remminafile;
remminafile = (RemminaFile*) data;
remminamain = (RemminaMain*) user_data;
store = GTK_LIST_STORE(remminamain->priv->file_model);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, PROTOCOL_COLUMN, remmina_file_get_icon_name(remminafile), NAME_COLUMN,
remmina_file_get_string(remminafile, "name"), GROUP_COLUMN,
remmina_file_get_string(remminafile, "group"), SERVER_COLUMN,
remmina_file_get_string(remminafile, "server"), FILENAME_COLUMN, remmina_file_get_filename(remminafile),
-1);
}
const gchar*
remmina_file_get_icon_name(RemminaFile *remminafile)
{
RemminaProtocolPlugin *plugin;
plugin = (RemminaProtocolPlugin *) remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
remmina_file_get_string(remminafile, "protocol"));
if (!plugin)
return "remmina";
return (remmina_file_get_int(remminafile, "ssh_enabled", FALSE) ? plugin->icon_name_ssh : plugin->icon_name);
}
static void remmina_file_editor_create_resolution(RemminaFileEditor* gfe, const RemminaProtocolSetting* setting,
GtkWidget* table, gint row)
{
GtkWidget* widget;
GtkWidget* hbox;
const gchar* resolution;
widget = gtk_label_new(_("Resolution"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
widget = gtk_radio_button_new_with_label(NULL, setting->opt1 ? _("Use window size") : _("Use client resolution"));
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2, row, row + 1);
gfe->priv->resolution_auto_radio = widget;
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 1, 2, row + 1, row + 2);
widget = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(gfe->priv->resolution_auto_radio), _("Custom"));
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
gfe->priv->resolution_custom_radio = widget;
resolution = remmina_file_get_string(gfe->priv->remmina_file, "resolution");
widget = remmina_public_create_combo_text_d(remmina_pref.resolutions, resolution, NULL);
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gfe->priv->resolution_custom_combo = widget;
widget = gtk_button_new_with_label("...");
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_browse_resolution), gfe);
g_signal_connect(G_OBJECT(gfe->priv->resolution_custom_radio), "toggled",
G_CALLBACK(remmina_file_editor_button_on_toggled), gfe->priv->resolution_custom_combo);
if (!resolution || strchr(resolution, 'x') == NULL)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_auto_radio), TRUE);
gtk_widget_set_sensitive(gfe->priv->resolution_custom_combo, FALSE);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_custom_radio), TRUE);
}
}
RemminaSSHShell*
remmina_ssh_shell_new_from_file (RemminaFile *remminafile)
{
RemminaSSHShell *shell;
shell = g_new0 (RemminaSSHShell, 1);
remmina_ssh_init_from_file (REMMINA_SSH (shell), remminafile);
shell->master = -1;
shell->slave = -1;
shell->exec = g_strdup (remmina_file_get_string (remminafile, "exec"));
return shell;
}
static void remmina_main_import_file_list(RemminaMain *remminamain, GSList *files)
{
GtkWidget *dlg;
GSList *element;
gchar *path;
RemminaFilePlugin *plugin;
GString *err;
RemminaFile *remminafile = NULL;
gboolean imported;
err = g_string_new(NULL);
imported = FALSE;
for (element = files; element; element = element->next)
{
path = (gchar*) element->data;
plugin = remmina_plugin_manager_get_import_file_handler(path);
if (plugin && (remminafile = plugin->import_func(path)) != NULL && remmina_file_get_string(remminafile, "name"))
{
remmina_file_generate_filename(remminafile);
remmina_file_save_all(remminafile);
imported = TRUE;
}
else
{
g_string_append(err, path);
g_string_append_c(err, '\n');
}
if (remminafile)
{
remmina_file_free(remminafile);
remminafile = NULL;
}
g_free(path);
}
g_slist_free(files);
if (err->len > 0)
{
dlg = gtk_message_dialog_new(GTK_WINDOW(remminamain), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Unable to import:\n%s"), err->str);
g_signal_connect(G_OBJECT(dlg), "response", G_CALLBACK(gtk_widget_destroy), NULL);
gtk_widget_show(dlg);
}
g_string_free(err, TRUE);
if (imported)
{
remmina_main_load_files(remminamain, TRUE);
}
}
static void remmina_file_editor_create_server(RemminaFileEditor* gfe, const RemminaProtocolSetting* setting, GtkWidget* table,
gint row)
{
RemminaProtocolPlugin* plugin = gfe->priv->plugin;
GtkWidget* widget;
#ifdef HAVE_LIBAVAHI_UI
GtkWidget* hbox;
#endif
gchar* s;
widget = gtk_label_new(_("Server"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
s = remmina_pref_get_recent(plugin->name);
widget = remmina_public_create_combo_entry(s, remmina_file_get_string(gfe->priv->remmina_file, "server"), TRUE);
gtk_widget_show(widget);
gtk_widget_set_tooltip_markup(widget, _(server_tips));
gtk_entry_set_activates_default(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget))), TRUE);
gfe->priv->server_combo = widget;
g_free(s);
#ifdef HAVE_LIBAVAHI_UI
if (setting->opt1)
{
gfe->priv->avahi_service_type = (const gchar*) setting->opt1;
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_button_new_with_label ("...");
s = g_strdup_printf(_("Browse the network to find a %s server"), plugin->name);
gtk_widget_set_tooltip_text (widget, s);
g_free(s);
gtk_widget_show(widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_browse_avahi), gfe);
gtk_table_attach_defaults (GTK_TABLE(table), hbox, 1, 2, row, row + 1);
}
else
#endif
{
gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2, row, row + 1);
}
}
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);
}
static void remmina_file_editor_ssh_auth_publickey_radio_on_toggled(GtkToggleButton* togglebutton, RemminaFileEditor* gfe)
{
gboolean b;
gchar* s;
b = ((!gfe->priv->ssh_enabled_check ||
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_enabled_check))) &&
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_auth_publickey_radio)));
gtk_widget_set_sensitive(gfe->priv->ssh_privatekey_chooser, b);
if (b && remmina_file_get_string (gfe->priv->remmina_file, "ssh_privatekey"))
{
s = remmina_ssh_find_identity ();
if (s)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (gfe->priv->ssh_privatekey_chooser), s);
g_free(s);
}
}
}
static gboolean remmina_file_editor_iterate_protocol(gchar* protocol, RemminaPlugin* plugin, gpointer data)
{
RemminaFileEditor* gfe = REMMINA_FILE_EDITOR(data);
GtkListStore* store;
GtkTreeIter iter;
gboolean first;
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(gfe->priv->protocol_combo)));
first = !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, protocol, 1, g_dgettext(plugin->domain, plugin->description), 2,
((RemminaProtocolPlugin*) plugin)->icon_name, -1);
if (first || g_strcmp0(protocol, remmina_file_get_string(gfe->priv->remmina_file, "protocol")) == 0)
{
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(gfe->priv->protocol_combo), &iter);
}
return FALSE;
}
void remmina_file_update_screen_resolution(RemminaFile *remminafile)
{
#if GTK_VERSION == 3
GdkDisplay *display;
GdkDeviceManager *device_manager;
GdkDevice *device;
#endif
GdkScreen *screen;
gchar *pos;
gchar *resolution;
gint x, y;
gint monitor;
GdkRectangle rect;
resolution = g_strdup(remmina_file_get_string(remminafile, "resolution"));
if (resolution == NULL || strchr(resolution, 'x') == NULL)
{
#if GTK_VERSION == 3
display = gdk_display_get_default();
device_manager = gdk_display_get_device_manager(display);
device = gdk_device_manager_get_client_pointer(device_manager);
gdk_device_get_position(device, &screen, &x, &y);
#elif GTK_VERSION == 2
gdk_display_get_pointer(gdk_display_get_default(), &screen, &x, &y, NULL);
#endif
monitor = gdk_screen_get_monitor_at_point(screen, x, y);
gdk_screen_get_monitor_geometry(screen, monitor, &rect);
remmina_file_set_int(remminafile, "resolution_width", rect.width);
remmina_file_set_int(remminafile, "resolution_height", rect.height);
}
else
{
pos = strchr(resolution, 'x');
*pos++ = '\0';
remmina_file_set_int(remminafile, "resolution_width", MAX(100, MIN(4096, atoi(resolution))));
remmina_file_set_int(remminafile, "resolution_height", MAX(100, MIN(4096, atoi(pos))));
}
g_free(resolution);
}
gchar*
remmina_file_get_secret(RemminaFile *remminafile, const gchar *setting)
{
RemminaSecretPlugin *plugin;
const gchar *cs;
plugin = remmina_plugin_manager_get_secret_plugin();
cs = remmina_file_get_string(remminafile, setting);
if (plugin && g_strcmp0(cs, ".") == 0)
{
if (remminafile->filename)
{
return plugin->get_password(remminafile, setting);
}
else
{
return NULL;
}
}
else
{
return g_strdup(cs);
}
}
gchar* remmina_file_manager_get_groups(void)
{
gchar dirname[MAX_PATH_LEN];
gchar filename[MAX_PATH_LEN];
GDir* dir;
const gchar* name;
RemminaFile* remminafile;
RemminaStringArray* array;
const gchar* group;
gchar* groups;
array = remmina_string_array_new();
g_snprintf(dirname, MAX_PATH_LEN, "%s/.remmina", g_get_home_dir());
dir = g_dir_open(dirname, 0, NULL);
if (dir == NULL)
return 0;
while ((name = g_dir_read_name(dir)) != NULL)
{
if (!g_str_has_suffix(name, ".remmina"))
continue;
g_snprintf(filename, MAX_PATH_LEN, "%s/%s", dirname, name);
remminafile = remmina_file_load(filename);
group = remmina_file_get_string(remminafile, "group");
if (group && remmina_string_array_find(array, group) < 0)
{
remmina_string_array_add(array, group);
}
remmina_file_free(remminafile);
}
g_dir_close(dir);
remmina_string_array_sort(array);
groups = remmina_string_array_to_string(array);
remmina_string_array_free(array);
return groups;
}
GtkDialog* remmina_ext_exec_new(RemminaFile* remminafile, const char *remmina_ext_exec_type)
{
TRACE_CALL(__func__);
GtkBuilder *builder;
PCon_Spinner *pcspinner;
GError *error = NULL;
char **argv;
gchar *cmd = NULL;
GString *cmd_str;
gchar pre[11];
gchar post[12];
GPid child_pid;
strcpy(pre, "precommand");
strcpy(post, "postcommand");
if (remmina_ext_exec_type != NULL && (
strcmp(remmina_ext_exec_type, pre) |
strcmp(remmina_ext_exec_type, post) )) {
cmd_str = g_string_new(remmina_file_get_string(remminafile, remmina_ext_exec_type));
remmina_utils_string_replace_all(cmd_str, "%h", remmina_file_get_string(remminafile, "server"));
remmina_utils_string_replace_all(cmd_str, "%t", remmina_file_get_string(remminafile, "ssh_server"));
remmina_utils_string_replace_all(cmd_str, "%u", remmina_file_get_string(remminafile, "username"));
remmina_utils_string_replace_all(cmd_str, "%U", remmina_file_get_string(remminafile, "ssh_username"));
remmina_utils_string_replace_all(cmd_str, "%p", remmina_file_get_string(remminafile, "name"));
remmina_utils_string_replace_all(cmd_str, "%g", remmina_file_get_string(remminafile, "group"));
}else{
return FALSE;
}
cmd = g_string_free(cmd_str, FALSE);
if (*cmd != 0) {
pcspinner = g_new(PCon_Spinner, 1);
builder = remmina_public_gtk_builder_new_from_file("remmina_spinner.glade");
pcspinner->dialog = GTK_DIALOG(gtk_builder_get_object(builder, "DialogSpinner"));
pcspinner->label_pleasewait = GTK_LABEL(GET_OBJECT("label_pleasewait"));
pcspinner->spinner = GTK_WIDGET(GET_OBJECT("spinner"));
pcspinner->button_cancel = GTK_BUTTON(GET_OBJECT("button_cancel"));
/* Connect signals */
gtk_builder_connect_signals(builder, NULL);
/* Exec a predefined command */
g_shell_parse_argv(cmd, NULL, &argv, &error);
if (error) {
g_warning("%s\n", error->message);
g_error_free(error);
}
/* Consider using G_SPAWN_SEARCH_PATH_FROM_ENVP (from glib 2.38)*/
g_spawn_async( NULL, // cwd
argv, // argv
NULL, // envp
G_SPAWN_SEARCH_PATH |
G_SPAWN_SEARCH_PATH_FROM_ENVP |
G_SPAWN_DO_NOT_REAP_CHILD, // flags
NULL, // child_setup
NULL, // child_setup user data
&child_pid, // pid location
&error); // error
if (!error) {
gtk_spinner_start(GTK_SPINNER(pcspinner->spinner));
g_child_watch_add(child_pid, wait_for_child, (gpointer)pcspinner);
gtk_dialog_run(pcspinner->dialog);
}else {
g_warning("Command %s exited with error: %s\n", cmd, error->message);
g_error_free(error);
}
g_strfreev(argv);
return (pcspinner->dialog);
}
return FALSE;
}
static void remmina_file_editor_create_ssh_tab(RemminaFileEditor* gfe, RemminaProtocolSSHSetting ssh_setting)
{
#ifdef HAVE_LIBSSH
RemminaFileEditorPriv* priv = gfe->priv;
GtkWidget* table;
GtkWidget* hbox;
GtkWidget* widget;
const gchar* cs;
gchar* s;
gint row = 0;
if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_NONE) return;
/* The SSH tab (implementation) */
if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_SSH ||
ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_SFTP)
{
s = remmina_public_combo_get_active_text (GTK_COMBO_BOX (priv->protocol_combo));
table = remmina_file_editor_create_notebook_tab (gfe, GTK_STOCK_DIALOG_AUTHENTICATION,
(s ? s : "SSH"), 8, 3);
g_free(s);
}
else
{
table = remmina_file_editor_create_notebook_tab (gfe, GTK_STOCK_DIALOG_AUTHENTICATION,
"SSH", 9, 3);
hbox = gtk_hbox_new (TRUE, 0);
gtk_widget_show(hbox);
gtk_table_attach_defaults (GTK_TABLE(table), hbox, 0, 3, 0, 1);
row++;
widget = gtk_check_button_new_with_label (_("Enable SSH tunnel"));
gtk_widget_show(widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "toggled",
G_CALLBACK(remmina_file_editor_ssh_enabled_check_on_toggled), gfe);
priv->ssh_enabled_check = widget;
widget = gtk_check_button_new_with_label (_("Tunnel via loopback address"));
gtk_widget_show(widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
priv->ssh_loopback_check = widget;
}
/* SSH Server group */
remmina_public_create_group (GTK_TABLE(table), _("SSH Server"), row, 3, 3);
row++;
switch (ssh_setting)
{
case REMMINA_PROTOCOL_SSH_SETTING_TUNNEL:
s = g_strdup_printf(_("Same server at port %i"), DEFAULT_SSH_PORT);
widget = gtk_radio_button_new_with_label (NULL, s);
g_free(s);
gtk_widget_show(widget);
gtk_table_attach_defaults (GTK_TABLE(table), widget, 1, 3, row, row + 1);
priv->ssh_server_default_radio = widget;
row++;
widget = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON(priv->ssh_server_default_radio), _("Custom"));
gtk_widget_show(widget);
gtk_table_attach (GTK_TABLE(table), widget, 1, 2, row, row + 1, GTK_FILL, 0, 0, 0);
g_signal_connect(G_OBJECT(widget), "toggled",
G_CALLBACK(remmina_file_editor_ssh_server_custom_radio_on_toggled), gfe);
priv->ssh_server_custom_radio = widget;
widget = gtk_entry_new ();
gtk_widget_show(widget);
gtk_entry_set_max_length (GTK_ENTRY(widget), 100);
gtk_widget_set_tooltip_markup (widget, _(server_tips2));
gtk_table_attach_defaults (GTK_TABLE(table), widget, 2, 3, row, row + 1);
priv->ssh_server_entry = widget;
row++;
break;
case REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL:
priv->ssh_server_default_radio = NULL;
priv->ssh_server_custom_radio = NULL;
priv->ssh_server_entry = remmina_file_editor_create_text (gfe, table, row, 1,
_("Server"), NULL);
gtk_widget_set_tooltip_markup (priv->ssh_server_entry, _(server_tips));
row++;
break;
case REMMINA_PROTOCOL_SSH_SETTING_SSH:
case REMMINA_PROTOCOL_SSH_SETTING_SFTP:
priv->ssh_server_default_radio = NULL;
priv->ssh_server_custom_radio = NULL;
priv->ssh_server_entry = NULL;
s = remmina_pref_get_recent ("SFTP");
priv->server_combo = remmina_file_editor_create_combo (gfe, table, row, 1,
_("Server"), s, remmina_file_get_string (priv->remmina_file, "server"));
gtk_widget_set_tooltip_markup (priv->server_combo, _(server_tips));
gtk_entry_set_activates_default (GTK_ENTRY(gtk_bin_get_child (GTK_BIN (priv->server_combo))), TRUE);
g_free(s);
row++;
break;
default:
break;
}
priv->ssh_charset_combo = remmina_file_editor_create_combo (gfe, table, row, 1,
_("Character set"), charset_list, remmina_file_get_string (priv->remmina_file, "ssh_charset"));
row++;
if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_SSH)
{
widget = remmina_file_editor_create_text (gfe, table, row, 1,
_("Startup program"), NULL);
cs = remmina_file_get_string (priv->remmina_file, "exec");
gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
g_hash_table_insert(priv->setting_widgets, "exec", widget);
row++;
}
else if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_SFTP)
{
widget = remmina_file_editor_create_text (gfe, table, row, 1,
_("Startup path"), NULL);
cs = remmina_file_get_string (priv->remmina_file, "execpath");
gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
g_hash_table_insert(priv->setting_widgets, "execpath", widget);
row++;
}
/* SSH Authentication frame */
remmina_public_create_group (GTK_TABLE(table), _("SSH Authentication"), row, 5, 3);
row++;
priv->ssh_username_entry = remmina_file_editor_create_text (gfe, table, row, 1,
_("User name"), NULL);
row++;
widget = gtk_radio_button_new_with_label (NULL, _("Password"));
gtk_widget_show(widget);
gtk_table_attach_defaults (GTK_TABLE(table), widget, 1, 3, row, row + 1);
priv->ssh_auth_password_radio = widget;
row++;
widget = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON(priv->ssh_auth_password_radio), _("Public key (automatic)"));
gtk_widget_show(widget);
gtk_table_attach_defaults (GTK_TABLE(table), widget, 1, 3, row, row + 1);
priv->ssh_auth_auto_publickey_radio = widget;
row++;
remmina_file_editor_create_ssh_privatekey (gfe, table, row, 1);
row++;
/* Set the values */
cs = remmina_file_get_string (priv->remmina_file, "ssh_server");
if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_TUNNEL)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->ssh_enabled_check),
remmina_file_get_int (priv->remmina_file, "ssh_enabled", FALSE));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->ssh_loopback_check),
remmina_file_get_int (priv->remmina_file, "ssh_loopback", FALSE));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(cs ?
priv->ssh_server_custom_radio : priv->ssh_server_default_radio), TRUE);
gtk_entry_set_text(GTK_ENTRY(priv->ssh_server_entry),
cs ? cs : "");
}
else if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->ssh_enabled_check),
remmina_file_get_int (priv->remmina_file, "ssh_enabled", FALSE));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->ssh_loopback_check),
remmina_file_get_int (priv->remmina_file, "ssh_loopback", FALSE));
gtk_entry_set_text(GTK_ENTRY(priv->ssh_server_entry),
cs ? cs : "");
}
cs = remmina_file_get_string (priv->remmina_file, "ssh_username");
gtk_entry_set_text(GTK_ENTRY(priv->ssh_username_entry), cs ? cs : "");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(
remmina_file_get_int (priv->remmina_file, "ssh_auth", 0) == SSH_AUTH_PUBLICKEY ?
priv->ssh_auth_publickey_radio :
remmina_file_get_int (priv->remmina_file, "ssh_auth", 0) == SSH_AUTH_AUTO_PUBLICKEY ?
priv->ssh_auth_auto_publickey_radio :
priv->ssh_auth_password_radio), TRUE);
remmina_file_editor_ssh_enabled_check_on_toggled (NULL, gfe);
#endif
}
static void remmina_file_editor_create_settings(RemminaFileEditor* gfe, GtkWidget* table,
const RemminaProtocolSetting* settings)
{
RemminaFileEditorPriv* priv = gfe->priv;
GtkWidget* hbox = NULL;
GtkWidget* widget;
gint row = 0;
gchar** strarr;
while (settings->type != REMMINA_PROTOCOL_SETTING_TYPE_END)
{
if (settings->compact)
{
if (hbox == NULL)
{
hbox = gtk_hbox_new(TRUE, 0);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 0, 2, row, row + 1);
}
}
switch (settings->type)
{
case REMMINA_PROTOCOL_SETTING_TYPE_SERVER:
remmina_file_editor_create_server(gfe, settings, table, row);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD:
remmina_file_editor_create_password(gfe, table, row);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION:
remmina_file_editor_create_resolution(gfe, settings, table, row);
row++;
break;
case REMMINA_PROTOCOL_SETTING_TYPE_KEYMAP:
strarr = remmina_pref_keymap_groups();
priv->keymap_combo = remmina_file_editor_create_select(gfe, table, row, 0,
_("Keyboard mapping"), (const gpointer*) strarr,
remmina_file_get_string(priv->remmina_file, "keymap"));
g_strfreev(strarr);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_SCALE:
widget = gtk_label_new(_("Horizontal scale"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
widget = gtk_label_new(_("Vertical scale"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row + 1, row + 2, GTK_FILL, 0, 0, 0);
widget = remmina_scaler_new();
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2, row, row + 2);
remmina_scaler_set(REMMINA_SCALER(widget),
remmina_file_get_int(priv->remmina_file, "hscale", 0),
remmina_file_get_int(priv->remmina_file, "vscale", 0),
remmina_file_get_int(priv->remmina_file, "aspectscale", FALSE));
priv->scaler_widget = widget;
row++;
break;
case REMMINA_PROTOCOL_SETTING_TYPE_TEXT:
widget = remmina_file_editor_create_text(gfe, table, row, 0,
g_dgettext(priv->plugin->domain, settings->label),
remmina_file_get_string(priv->remmina_file, settings->name));
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_SELECT:
widget = remmina_file_editor_create_select(gfe, table, row, 0,
g_dgettext(priv->plugin->domain, settings->label),
(const gpointer*) settings->opt1,
remmina_file_get_string(priv->remmina_file, settings->name));
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_COMBO:
widget = remmina_file_editor_create_combo(gfe, table, row, 0,
g_dgettext(priv->plugin->domain, settings->label),
(const gchar*) settings->opt1,
remmina_file_get_string(priv->remmina_file, settings->name));
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_CHECK:
widget = remmina_file_editor_create_check(gfe, (hbox ? hbox : table), (hbox ? -1 : row), 0,
g_dgettext (priv->plugin->domain, settings->label),
remmina_file_get_int (priv->remmina_file, (gchar*) settings->name, FALSE));
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_FILE:
widget = remmina_file_editor_create_chooser (gfe, table, row, 0,
g_dgettext (priv->plugin->domain, settings->label),
remmina_file_get_string (priv->remmina_file, settings->name),
GTK_FILE_CHOOSER_ACTION_OPEN);
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
case REMMINA_PROTOCOL_SETTING_TYPE_FOLDER:
widget = remmina_file_editor_create_chooser (gfe, table, row, 0,
g_dgettext (priv->plugin->domain, settings->label),
remmina_file_get_string (priv->remmina_file, settings->name),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
g_hash_table_insert(priv->setting_widgets, (gchar*) settings->name, widget);
break;
default:
break;
}
if (!settings->compact)
{
hbox = NULL;
row++;
}
settings++;
}
gtk_table_resize(GTK_TABLE(table), row, 2);
}
GtkWidget* remmina_file_editor_new_from_file(RemminaFile* remminafile)
{
RemminaFileEditor* gfe;
RemminaFileEditorPriv* priv;
GtkWidget* table;
GtkWidget* widget;
gchar* groups;
gchar* s;
const gchar* cs;
gfe = REMMINA_FILE_EDITOR(g_object_new(REMMINA_TYPE_FILE_EDITOR, NULL));
priv = gfe->priv;
priv->remmina_file = remminafile;
if (remmina_file_get_filename(remminafile) == NULL)
{
gtk_dialog_set_response_sensitive(GTK_DIALOG(gfe), GTK_RESPONSE_APPLY, FALSE);
}
/* Create the Profile group on the top (for name and protocol) */
table = gtk_table_new(4, 3, FALSE);
gtk_widget_show(table);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
gtk_container_set_border_width(GTK_CONTAINER(table), 8);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(gfe))), table, FALSE, FALSE, 2);
remmina_public_create_group(GTK_TABLE(table), _("Profile"), 0, 4, 3);
/* Profile: Name */
widget = gtk_label_new(_("Name"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
widget = gtk_entry_new();
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 2, 3, 1, 2);
gtk_entry_set_max_length(GTK_ENTRY(widget), 100);
priv->name_entry = widget;
if (remmina_file_get_filename(remminafile) == NULL)
{
gtk_entry_set_text(GTK_ENTRY(widget), _("Quick Connect"));
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_file_editor_name_on_changed), gfe);
}
else
{
cs = remmina_file_get_string(remminafile, "name");
gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
}
/* Profile: Group */
widget = gtk_label_new(_("Group"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
groups = remmina_file_manager_get_groups();
priv->group_combo = remmina_public_create_combo_entry(groups, remmina_file_get_string(remminafile, "group"), FALSE);
g_free(groups);
gtk_widget_show(priv->group_combo);
gtk_table_attach_defaults(GTK_TABLE(table), priv->group_combo, 2, 3, 2, 3);
gtk_widget_set_sensitive(priv->group_combo, FALSE);
s = g_strdup_printf(_("Use '%s' as subgroup delimiter"), "/");
gtk_widget_set_tooltip_text(priv->group_combo, s);
g_free(s);
/* Profile: Protocol */
widget = gtk_label_new(_("Protocol"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 3, 4, GTK_FILL, 0, 0, 0);
widget = remmina_public_create_combo(TRUE);
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 2, 3, 3, 4);
priv->protocol_combo = widget;
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, remmina_file_editor_iterate_protocol, gfe);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_file_editor_protocol_combo_on_changed), gfe);
/* Create the Preference frame */
widget = gtk_event_box_new();
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(gfe))), widget, TRUE, TRUE, 2);
priv->config_box = widget;
priv->config_container = NULL;
remmina_file_editor_protocol_combo_on_changed(GTK_COMBO_BOX(priv->protocol_combo), gfe);
remmina_file_editor_check_profile(gfe);
return GTK_WIDGET(gfe);
}
static void remmina_file_editor_update_resolution(GtkWidget* widget, RemminaFileEditor* gfe)
{
remmina_public_load_combo_text_d(gfe->priv->resolution_custom_combo, remmina_pref.resolutions,
remmina_file_get_string(gfe->priv->remmina_file, "resolution"), NULL);
}
