41 #include <glib/gi18n.h> 56 #ifdef GDK_WINDOWING_WAYLAND 57 #include <gdk/gdkwayland.h> 115 DESKTOP_RESIZE_SIGNAL,
118 UNLOCK_DYNRES_SIGNAL,
132 TRACE_CALL(__func__);
135 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
138 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
141 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
144 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
147 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
150 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
156 TRACE_CALL(__func__);
164 REMMINA_DEBUG(
"LibSSH support turned off, no need to free SSH tunnel data");
174 TRACE_CALL(__func__);
219 TRACE_CALL(__func__);
222 child = gtk_bin_get_child(GTK_BIN(gp));
225 gtk_widget_set_can_focus(child, TRUE);
226 gtk_widget_grab_focus(child);
232 TRACE_CALL(__func__);
245 TRACE_CALL(__func__);
248 REMMINA_DEBUG(
"Opening connection");
269 if (num_plugin + num_ssh == 0) {
276 feature += num_plugin;
279 REMMINA_DEBUG(
"Have SSH");
282 feature->
id = REMMINA_PROTOCOL_FEATURE_TOOL_SSH;
283 feature->
opt1 = _(
"Connect via SSH from a new terminal");
285 feature->
opt2 =
"utilities-terminal";
287 feature->
opt3 = NULL;
292 feature->
id = REMMINA_PROTOCOL_FEATURE_TOOL_SFTP;
293 feature->
opt1 = _(
"Open SFTP transfer…");
295 feature->
opt2 =
"folder-remote";
297 feature->
opt3 = NULL;
318 TRACE_CALL(__func__);
321 RemminaMessagePanel *mp;
333 s = g_strdup_printf(_(
"Connecting to “%s”…"), (name ? name :
"*"));
346 TRACE_CALL(__func__);
356 g_signal_emit_by_name(G_OBJECT(gp),
"disconnect");
357 return G_SOURCE_REMOVE;
364 TRACE_CALL(__func__);
371 TRACE_CALL(__func__);
392 g_signal_emit_by_name(G_OBJECT(gp),
"connect");
393 return G_SOURCE_REMOVE;
400 TRACE_CALL(__func__);
406 TRACE_CALL(__func__);
409 g_signal_emit_by_name(G_OBJECT(gp),
"update-align");
410 return G_SOURCE_REMOVE;
416 TRACE_CALL(__func__);
422 TRACE_CALL(__func__);
425 g_signal_emit_by_name(G_OBJECT(gp),
"lock-dynres");
426 return G_SOURCE_REMOVE;
431 TRACE_CALL(__func__);
434 g_signal_emit_by_name(G_OBJECT(gp),
"unlock-dynres");
435 return G_SOURCE_REMOVE;
441 TRACE_CALL(__func__);
448 TRACE_CALL(__func__);
454 TRACE_CALL(__func__);
457 g_signal_emit_by_name(G_OBJECT(gp),
"desktop-resize");
458 return G_SOURCE_REMOVE;
464 TRACE_CALL(__func__);
471 TRACE_CALL(__func__);
476 if (!GTK_IS_WIDGET(gp))
490 g_signal_emit_by_name(G_OBJECT(gp),
"disconnect");
514 TRACE_CALL(__func__);
515 gchar *keystrokes = g_object_get_data(G_OBJECT(widget),
"keystrokes");
518 GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
525 typedef struct _KeystrokeReplace {
531 KeystrokeReplace keystrokes_replaces[] =
533 {
"\\n",
"\n", GDK_KEY_Return },
534 {
"\\t",
"\t", GDK_KEY_Tab },
535 {
"\\b",
"\b", GDK_KEY_BackSpace },
536 {
"\\e",
"\e", GDK_KEY_Escape },
537 {
"\\\\",
"\\", GDK_KEY_backslash },
544 for (i = 0; keystrokes_replaces[i].replace; i++) {
545 REMMINA_DEBUG(
"Keystrokes before replacement is \'%s\'", keystrokes);
547 keystrokes_replaces[i].search,
548 keystrokes_replaces[i].replace));
549 REMMINA_DEBUG(
"Keystrokes after replacement is \'%s\'", keystrokes);
551 gchar *iter = g_strdup(keystrokes);
552 keyvals = (guint *)g_malloc(strlen(keystrokes));
555 character = g_utf8_get_char_validated(iter, -1);
558 keyval = gdk_unicode_to_keyval(character);
560 for (i = 0; keystrokes_replaces[i].replace; i++) {
561 if (character == keystrokes_replaces[i].replace[0]) {
562 keys = g_new0(GdkKeymapKey, 1);
563 keyval = keystrokes_replaces[i].keyval;
572 if (!gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
573 g_warning(
"keyval 0x%04x has no keycode!", keyval);
574 iter = g_utf8_find_next_char(iter, NULL);
581 keyvals[n_keys++] = GDK_KEY_Shift_L;
583 keyvals[n_keys++] = GDK_KEY_Alt_R;
584 keyvals[n_keys++] = keyval;
589 iter = g_utf8_find_next_char(iter, NULL);
605 TRACE_CALL(__func__);
607 gchar *text = g_utf8_normalize(clip_text, -1, G_NORMALIZE_DEFAULT_COMPOSE);
610 GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
617 typedef struct _KeystrokeReplace {
623 KeystrokeReplace text_replaces[] =
625 {
"\\n",
"\n", GDK_KEY_Return },
626 {
"\\t",
"\t", GDK_KEY_Tab },
627 {
"\\b",
"\b", GDK_KEY_BackSpace },
628 {
"\\e",
"\e", GDK_KEY_Escape },
629 {
"\\\\",
"\\", GDK_KEY_backslash },
636 for (i = 0; text_replaces[i].replace; i++) {
637 REMMINA_DEBUG(
"Text clipboard before replacement is \'%s\'", text);
639 text_replaces[i].search,
640 text_replaces[i].replace));
641 REMMINA_DEBUG(
"Text clipboard after replacement is \'%s\'", text);
643 gchar *iter = g_strdup(text);
644 REMMINA_DEBUG(
"Iter: %s", iter),
645 keyvals = (guint *)g_malloc(strlen(text));
648 character = g_utf8_get_char_validated(iter, -1);
649 REMMINA_DEBUG(
"Char: U+%04" G_GINT32_FORMAT
"X", character);
652 keyval = gdk_unicode_to_keyval(character);
653 REMMINA_DEBUG(
"Keyval: %u", keyval);
655 for (i = 0; text_replaces[i].replace; i++) {
656 if (character == text_replaces[i].replace[0]) {
657 keys = g_new0(GdkKeymapKey, 1);
658 keyval = text_replaces[i].keyval;
659 REMMINA_DEBUG(
"Special Keyval: %u", keyval);
668 if (!gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
669 REMMINA_WARNING(
"keyval 0x%04x has no keycode!", keyval);
670 iter = g_utf8_find_next_char(iter, NULL);
677 keyvals[n_keys++] = GDK_KEY_Shift_L;
679 keyvals[n_keys++] = GDK_KEY_Alt_R;
685 keyvals[n_keys++] = keyval;
690 iter = g_utf8_find_next_char(iter, NULL);
701 TRACE_CALL(__func__);
702 GtkClipboard *clipboard;
704 clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
709 gtk_clipboard_request_text(clipboard,
715 TRACE_CALL(__func__);
717 REMMINA_DEBUG(
"plugin screenshot function is not implemented, using core Remmina functionality");
726 TRACE_CALL(__func__);
728 REMMINA_DEBUG(
"Map plugin function not implemented");
732 REMMINA_DEBUG(
"Calling plugin mapping function");
738 TRACE_CALL(__func__);
740 REMMINA_DEBUG(
"Unmap plugin function not implemented");
744 REMMINA_DEBUG(
"Calling plugin unmapping function");
750 TRACE_CALL(__func__);
752 REMMINA_DEBUG(
"Emitting signals should be used from the object itself, not from another object");
759 d->
func = FUNC_PROTOCOLWIDGET_EMIT_SIGNAL;
766 g_signal_emit_by_name(G_OBJECT(gp), signal_name);
771 TRACE_CALL(__func__);
777 TRACE_CALL(__func__);
787 if (feature->
type == type)
794 TRACE_CALL(__func__);
800 TRACE_CALL(__func__);
804 if (feature->
type == type && (
id == 0 || feature->
id ==
id)) {
813 TRACE_CALL(__func__);
814 switch (feature->
id) {
816 case REMMINA_PROTOCOL_FEATURE_TOOL_SSH:
825 case REMMINA_PROTOCOL_FEATURE_TOOL_SFTP:
842 TRACE_CALL(__func__);
850 TRACE_CALL(__func__);
859 TRACE_CALL(__func__);
866 TRACE_CALL(__func__);
872 RemminaMessagePanel *mp;
878 d->
func = FUNC_PROTOCOLWIDGET_MPPROGRESS;
901 d->
func = FUNC_PROTOCOLWIDGET_MPDESTROY;
914 printf(
"Remmina: Cancelling an opening tunnel is not implemented\n");
919 TRACE_CALL(__func__);
923 RemminaMessagePanel *mp;
924 gboolean partial = FALSE;
925 gboolean cont = FALSE;
929 REMMINA_DEBUG(
"Creating SSH tunnel to “%s” via SSH…", REMMINA_SSH(tunnel)->server);
931 msg = g_strdup_printf(_(
"Connecting to “%s” via SSH…"), REMMINA_SSH(tunnel)->server);
941 REMMINA_DEBUG(
"SSH Tunnel init session error: %s", REMMINA_SSH(tunnel)->error);
949 REMMINA_DEBUG(
"Tunnel auth returned %d", ret);
952 REMMINA_DEBUG(
"Authentication success");
955 REMMINA_DEBUG(
"Continue with the next auth method");
961 REMMINA_DEBUG(
"Reconnecting…");
962 if (REMMINA_SSH(tunnel)->session) {
963 ssh_disconnect(REMMINA_SSH(tunnel)->session);
964 ssh_free(REMMINA_SSH(tunnel)->session);
965 REMMINA_SSH(tunnel)->session = NULL;
967 g_free(REMMINA_SSH(tunnel)->callback);
972 REMMINA_DEBUG(
"Interrupted by the user");
977 REMMINA_DEBUG(
"Error during the authentication: %s", REMMINA_SSH(tunnel)->error);
991 REMMINA_DEBUG(
"Cannot init SSH session with tunnel struct");
998 REMMINA_DEBUG(
"Tunnel auth returned %d", ret);
1023 printf(
"Remmina: Cancelling start_direct_tunnel is not implemented\n");
1028 TRACE_CALL(__func__);
1032 #if GLIB_CHECK_VERSION(2, 54, 0) 1033 gboolean found = g_ptr_array_find(gp->
priv->
ssh_tunnels, tunnel, &idx);
1036 gboolean found = FALSE;
1045 printf(
"Tunnel %s found at idx = %d\n", found ?
"yes":
"not", idx);
1049 REMMINA_DEBUG(
"[Tunnel with idx %u has been disconnected", idx);
1064 TRACE_CALL(__func__);
1065 const gchar *server;
1066 const gchar *ssh_tunnel_server;
1067 gchar *ssh_tunnel_host, *srv_host, *dest;
1068 gint srv_port, ssh_tunnel_port = 0;
1070 REMMINA_DEBUG(
"SSH tunnel initialization…");
1076 return g_strdup(
"");
1078 if (strstr(g_strdup(server),
"unix:///") != NULL) {
1079 REMMINA_DEBUG(
"%s is a UNIX socket", server);
1080 return g_strdup(server);
1083 REMMINA_DEBUG(
"Calling remmina_public_get_server_port");
1085 REMMINA_DEBUG(
"Calling remmina_public_get_server_port (tunnel)");
1087 REMMINA_DEBUG(
"server: %s, port: %d", srv_host, srv_port);
1089 if (port_plus && srv_port < 100)
1091 srv_port += default_port;
1095 RemminaMessagePanel *mp;
1099 dest = g_strdup_printf(
"[%s]:%i", srv_host, srv_port);
1101 g_free(ssh_tunnel_host);
1108 g_free(ssh_tunnel_host);
1109 REMMINA_DEBUG(
"remmina_protocol_widget_init_tunnel failed with error is %s",
1115 msg = g_strdup_printf(_(
"Connecting to “%s” via SSH…"), server);
1121 g_free(ssh_tunnel_host);
1122 ssh_tunnel_host = NULL;
1123 srv_host = g_strdup(
"127.0.0.1");
1126 REMMINA_DEBUG(
"Starting tunnel to: %s, port: %d", ssh_tunnel_host, ssh_tunnel_port);
1129 g_free(ssh_tunnel_host);
1135 g_free(ssh_tunnel_host);
1148 dest = g_strdup_printf(
"[%s]:%i", srv_host, srv_port);
1150 g_free(ssh_tunnel_host);
1159 printf(
"Remmina: Cancelling start_reverse_tunnel is not implemented\n");
1166 TRACE_CALL(__func__);
1169 RemminaMessagePanel *mp;
1197 TRACE_CALL(__func__);
1200 ssh_channel channel;
1202 gboolean ret = FALSE;
1211 if ((channel = ssh_channel_new(REMMINA_SSH(tunnel)->session)) == NULL)
1214 va_start(args, fmt);
1215 cmd = g_strdup_vprintf(fmt, args);
1218 if (ssh_channel_open_session(channel) == SSH_OK &&
1219 ssh_channel_request_exec(channel, cmd) == SSH_OK) {
1221 ssh_channel_send_eof(channel);
1222 status = ssh_channel_get_exit_status(channel);
1223 ptr = strchr(cmd,
' ');
1224 if (ptr) *ptr =
'\0';
1232 _(
"The “%s” command is not available on the SSH server."), cmd);
1237 _(
"Could not run the “%s” command on the SSH server (status = %i)."), cmd, status);
1249 ssh_channel_close(channel);
1250 ssh_channel_free(channel);
1263 TRACE_CALL(__func__);
1269 REMMINA_DEBUG(
"Calling remmina_public_get_server_port");
1280 TRACE_CALL(__func__);
1286 TRACE_CALL(__func__);
1289 if (REMMINA_SSH(tunnel)->error)
1299 printf(
"Remmina: Cancelling an XPort connection is not implemented\n");
1304 TRACE_CALL(__func__);
1306 gboolean bindlocalhost;
1309 RemminaMessagePanel *mp;
1325 REMMINA_DEBUG(
"Calling remmina_public_get_server_port");
1327 bindlocalhost = (g_strcmp0(REMMINA_SSH(tunnel)->server, server) == 0);
1332 ssh_get_error(REMMINA_SSH(tunnel)->session));
1349 TRACE_CALL(__func__);
1356 tunnel->
localdisplay = g_strdup_printf(
"unix:%i", display);
1362 TRACE_CALL(__func__);
1369 TRACE_CALL(__func__);
1372 REMMINA_DEBUG(
"Multi monitor is set to %d", gp->
priv->
multimon);
1378 TRACE_CALL(__func__);
1385 TRACE_CALL(__func__);
1391 TRACE_CALL(__func__);
1397 TRACE_CALL(__func__);
1403 TRACE_CALL(__func__);
1409 TRACE_CALL(__func__);
1415 TRACE_CALL(__func__);
1421 TRACE_CALL(__func__);
1427 TRACE_CALL(__func__);
1433 TRACE_CALL(__func__);
1440 TRACE_CALL(__func__);
1446 TRACE_CALL(__func__);
1452 TRACE_CALL(__func__);
1463 va_start(args, fmt);
1472 TRACE_CALL(__func__);
1478 TRACE_CALL(__func__);
1505 if (button == GTK_RESPONSE_OK) {
1525 pthread_cond_signal(&d->
pt_cond);
1526 pthread_mutex_unlock(&d->
pt_mutex);
1538 RemminaMessagePanel *mp;
1575 RemminaMessagePanel *
mp;
1583 if (g_main_loop_is_running(mpri->
loop))
1584 g_main_loop_quit(mpri->
loop);
1599 mpri->
response = GTK_RESPONSE_CANCEL;
1608 mpri->
response = GTK_RESPONSE_CANCEL;
1613 const gchar *title,
const gchar *default_username,
const gchar *default_password,
const gchar *default_domain,
1614 const gchar *strpasswordlabel)
1616 TRACE_CALL(__func__);
1624 d->
title = g_strdup(title);
1633 MpRunInfo mpri = { NULL, NULL, GTK_RESPONSE_CANCEL, FALSE };
1635 gulong unmap_handler;
1636 gulong destroy_handler;
1637 gulong response_handler;
1643 if (!gtk_widget_get_visible(GTK_WIDGET(mpri.
mp)))
1644 gtk_widget_show(GTK_WIDGET(mpri.
mp));
1649 g_object_ref(mpri.
mp);
1651 mpri.
loop = g_main_loop_new(NULL, FALSE);
1652 g_main_loop_run(mpri.
loop);
1653 g_main_loop_unref(mpri.
loop);
1656 g_signal_handler_disconnect(mpri.
mp, response_handler);
1657 g_signal_handler_disconnect(mpri.
mp, destroy_handler);
1658 g_signal_handler_disconnect(mpri.
mp, unmap_handler);
1660 g_object_unref(mpri.
mp);
1668 pthread_cond_init(&d->
pt_cond, NULL);
1669 pthread_mutex_init(&d->
pt_mutex, NULL);
1674 pthread_mutex_destroy(&d->
pt_mutex);
1675 pthread_cond_destroy(&d->
pt_cond);
1697 TRACE_CALL(__func__);
1699 default_password, default_domain, password_prompt == NULL ? _(
"Password") : password_prompt);
1704 TRACE_CALL(__func__);
1711 !remminafile->prevent_saving && allow_password_saving)
1718 password, NULL, _(
"Password"));
1758 TRACE_CALL(__func__);
1766 TRACE_CALL(__func__);
1773 rc = GTK_RESPONSE_OK;
1777 s = g_strdup_printf(
1778 "<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
1780 _(
"Certificate details:"),
1782 _(
"Subject:"), subject,
1784 _(
"Issuer:"), issuer,
1786 _(
"Fingerprint:"), fingerprint,
1788 _(
"Accept certificate?"));
1793 return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
1798 TRACE_CALL(__func__);
1805 rc = GTK_RESPONSE_OK;
1809 s = g_strdup_printf(
1810 "<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
1812 _(
"The certificate changed! Details:"),
1814 _(
"Subject:"), subject,
1816 _(
"Issuer:"), issuer,
1818 _(
"Old fingerprint:"), old_fingerprint,
1820 _(
"New fingerprint:"), new_fingerprint,
1822 _(
"Accept changed certificate?"));
1827 return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
1832 TRACE_CALL(__func__);
1838 TRACE_CALL(__func__);
1844 TRACE_CALL(__func__);
1850 TRACE_CALL(__func__);
1856 TRACE_CALL(__func__);
1860 return s && s[0] ? g_strdup(s) : NULL;
1865 TRACE_CALL(__func__);
1869 return s && s[0] ? g_strdup(s) : NULL;
1874 TRACE_CALL(__func__);
1878 return s && s[0] ? g_strdup(s) : NULL;
1883 TRACE_CALL(__func__);
1887 return s && s[0] ? g_strdup(s) : NULL;
1892 TRACE_CALL(__func__);
1896 gboolean save = FALSE;
1902 d->
func = FUNC_INIT_SAVE_CRED;
1946 TRACE_CALL(__func__);
1947 RemminaMessagePanel *mp;
1954 d->
func = FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN;
1963 s = g_strdup_printf(
1965 _(
"Listening on port %i for an incoming %s connection…"), port,
1975 TRACE_CALL(__func__);
1976 RemminaMessagePanel *mp;
1982 d->
func = FUNC_PROTOCOLWIDGET_MPSHOWRETRY;
1997 TRACE_CALL(__func__);
1998 printf(
"Remmina: The %s function is not implemented, and is left here only for plugin API compatibility.\n", __func__);
2003 TRACE_CALL(__func__);
2004 printf(
"Remmina: The %s function is not implemented, and is left here only for plugin API compatibility.\n", __func__);
2009 TRACE_CALL(__func__);
2016 TRACE_CALL(__func__);
2021 g_signal_connect_swapped(G_OBJECT(gp->
priv->
chat_window),
"send", G_CALLBACK(on_send), gp);
2024 g_signal_connect_swapped(G_OBJECT(gp->
priv->
chat_window),
"destroy", G_CALLBACK(on_destroy), gp);
2031 TRACE_CALL(__func__);
2038 TRACE_CALL(__func__);
2046 d->
func = FUNC_CHAT_RECEIVE;
2095 return GTK_WIDGET(g_object_new(REMMINA_TYPE_PROTOCOL_WIDGET, NULL));
2104 TRACE_CALL(__func__);
2108 GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
2110 event.window = gtk_widget_get_window(widget);
2111 event.send_event = TRUE;
2112 event.time = GDK_CURRENT_TIME;
2118 if (action & GDK_KEY_PRESS) {
2120 event.type = GDK_KEY_PRESS;
2121 for (i = 0; i < keyvals_length; i++) {
2122 event.keyval = keyvals[i];
2125 REMMINA_DEBUG(
"Sending keyval: %u, hardware_keycode: %u", event.keyval, event.hardware_keycode);
2126 g_signal_emit_by_name(G_OBJECT(widget),
"key-press-event", &event, &result);
2130 if (action & GDK_KEY_RELEASE) {
2132 event.type = GDK_KEY_RELEASE;
2133 for (i = (keyvals_length - 1); i >= 0; i--) {
2134 event.keyval = keyvals[i];
2137 g_signal_emit_by_name(G_OBJECT(widget),
"key-release-event", &event, &result);
2144 TRACE_CALL(__func__);
2163 if (wfile <= 0 || hfile <= 0)
2172 gtk_widget_get_allocation(GTK_WIDGET(gp), &al);
2174 w = al.width - al.width % 4;
2175 h = al.height - al.height % 4;
2177 printf(
"Remmina warning: %s RemminaProtocolWidget w=%d h=%d are too small, adjusting to 640x480\n", __func__, w, h);
2185 if (h > rect.height)
struct remmina_masterthread_exec_data::@12::@14 init_save_creds
enum remmina_ssh_auth_result remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *remminafile)
const gchar * remmina_file_get_string(RemminaFile *remminafile, const gchar *setting)
RemminaSSHTunnelCallback destroy_func
gboolean remmina_ssh_tunnel_reverse(RemminaSSHTunnel *tunnel, gint port, gint local_port)
void remmina_message_panel_setup_auth(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data, const gchar *title, const gchar *password_prompt, unsigned flags)
void(* call_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
void remmina_message_panel_setup_question(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
gchar * remmina_message_panel_field_get_filename(RemminaMessagePanel *mp, int entryid)
const gchar * remmina_file_get_filename(RemminaFile *remminafile)
void remmina_public_send_notification(const gchar *notification_id, const gchar *notification_title, const gchar *notification_message)
typedefG_BEGIN_DECLS struct _RemminaFile RemminaFile
void rco_show_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
Each cnnobj->page can have more than one RemminaMessagePanel, but 0 or 1 are visible.
gpointer destroy_func_callback_data
RemminaFile * remmina_file_dup_temp_protocol(RemminaFile *remminafile, const gchar *new_protocol)
GtkWidget * rcw_open_from_file_full(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler)
void remmina_message_panel_setup_auth_x509(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
void(* init)(RemminaProtocolWidget *gp)
const RemminaProtocolFeature * features
struct remmina_masterthread_exec_data::@12::@24 protocolwidget_panelshowlisten
void rco_destroy_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
Deletes a RemminaMessagePanel from the current cnnobj and if it was visible, make visible the last re...
gboolean(* open_connection)(RemminaProtocolWidget *gp)
void remmina_message_panel_field_set_string(RemminaMessagePanel *mp, int entryid, const gchar *text)
RemminaProtocolWidgetResolutionMode
RemminaSSHTunnelCallback disconnect_func
gchar * remmina_public_str_replace_in_place(gchar *string, const gchar *search, const gchar *replacement)
GtkDialog * remmina_ext_exec_new(RemminaFile *remminafile, const char *remmina_ext_exec_type)
struct remmina_masterthread_exec_data::@12::@21 protocolwidget_mpprogress
void remmina_message_panel_field_set_filename(RemminaMessagePanel *mp, int entryid, const gchar *filename)
GtkWindow * rcw_get_gtkwindow(RemminaConnectionObject *cnnobj)
gboolean remmina_masterthread_exec_is_main_thread()
struct remmina_masterthread_exec_data::@12::@22 protocolwidget_mpdestroy
gboolean(* unmap_event)(RemminaProtocolWidget *gp)
struct remmina_masterthread_exec_data::@12::@23 protocolwidget_mpshowretry
RemminaProtocolFeatureType type
void(* send_keystrokes)(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen)
void remmina_ssh_set_error(RemminaSSH *ssh, const gchar *fmt)
gboolean remmina_ssh_tunnel_xport(RemminaSSHTunnel *tunnel, gboolean bindlocalhost)
RemminaSSHTunnel * remmina_ssh_tunnel_new_from_file(RemminaFile *remminafile)
RemminaSSHTunnelCallback init_func
void remmina_message_panel_field_set_switch(RemminaMessagePanel *mp, int entryid, gboolean state)
RemminaTypeHint opt1_type_hint
gboolean remmina_pref_get_boolean(const gchar *key)
void remmina_ssh_tunnel_cancel_accept(RemminaSSHTunnel *tunnel)
void remmina_ssh_tunnel_free(RemminaSSHTunnel *tunnel)
RemminaProtocolFeatureType
gboolean(* close_connection)(RemminaProtocolWidget *gp)
void remmina_masterthread_exec_and_wait(RemminaMTExecData *d)
GtkWidget * rcw_get_gtkviewport(RemminaConnectionObject *cnnobj)
void(* RemminaMessagePanelCallback)(void *user_data, int button)
gchar * remmina_message_panel_field_get_string(RemminaMessagePanel *mp, int entryid)
RemminaTypeHint opt2_type_hint
void remmina_message_panel_setup_progress(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
gint remmina_file_get_int(RemminaFile *remminafile, const gchar *setting, gint default_value)
gboolean(* map_event)(RemminaProtocolWidget *gp)
gboolean(* query_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
RemminaPlugin * remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name)
guint16 remmina_public_get_keycode_for_keyval(GdkKeymap *keymap, guint keyval)
gpointer RemminaTunnelInitFunc
gboolean remmina_public_get_modifier_for_keycode(GdkKeymap *keymap, guint16 keycode)
struct remmina_masterthread_exec_data::@12::@15 chat_receive
union remmina_masterthread_exec_data::@12 p
struct remmina_masterthread_exec_data::@12::@20 protocolwidget_emit_signal
gboolean(* get_plugin_screenshot)(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd)
gboolean remmina_message_panel_field_get_switch_state(RemminaMessagePanel *mp, int entryid)
void remmina_file_set_string(RemminaFile *remminafile, const gchar *setting, const gchar *value)
void remmina_file_save(RemminaFile *remminafile)
void rco_get_monitor_geometry(RemminaConnectionObject *cnnobj, GdkRectangle *sz)
void remmina_ssh_set_application_error(RemminaSSH *ssh, const gchar *fmt,...)
void remmina_chat_window_receive(RemminaChatWindow *window, const gchar *name, const gchar *text)
void remmina_public_get_server_port(const gchar *server, gint defaultport, gchar **host, gint *port)
gboolean remmina_ssh_tunnel_open(RemminaSSHTunnel *tunnel, const gchar *host, gint port, gint local_port)
GtkWidget * remmina_chat_window_new(GtkWindow *parent, const gchar *chat_with)
enum remmina_masterthread_exec_data::@11 func
gboolean(* RemminaXPortTunnelInitFunc)(RemminaProtocolWidget *gp, gint remotedisplay, const gchar *server, gint port)
void remmina_message_panel_response(RemminaMessagePanel *mp, gint response_id)
RemminaMessagePanel * remmina_message_panel_new()
RemminaTypeHint opt3_type_hint
RemminaSSHTunnelCallback connect_func
gboolean remmina_ssh_init_session(RemminaSSH *ssh)