remmina_mpchange.c

Go to the documentation of this file.

/*
 * Remmina - The GTK+ Remote Desktop Client
 * Copyright (C) 2009-2011 Vic Lee
 * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
 * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
 *
 * 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of portions of this program with the
 *  OpenSSL library under certain conditions as described in each
 *  individual source file, and distribute linked combinations
 *  including the two.
 *  You must obey the GNU General Public License in all respects
 *  for all of the code used other than OpenSSL. *  If you modify
 *  file(s) with this exception, you may extend this exception to your
 *  version of the file(s), but you are not obligated to do so. *  If you
 *  do not wish to do so, delete this exception statement from your
 *  version. *  If you delete this exception statement from all source
 *  files in the program, then also delete it here.
 *
 */

#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include "config.h"
#include "remmina_mpchange.h"
#include "remmina_file.h"
#include "remmina_file_manager.h"
#include "remmina_pref.h"
#include "remmina_public.h"
#include "remmina_main.h"
#include "remmina_plugin_manager.h"
#include "remmina_log.h"
#include "remmina/remmina_trace_calls.h"

#define GET_DIALOG_OBJECT(object_name) gtk_builder_get_object(bu, object_name)

struct mpchanger_params {
    gchar *username;        // New username
    gchar *domain;          // New domain
    gchar *password;        // New password
    gchar *group;
    gchar *gatewayusername;
    gchar *gatewaydomain;
    gchar *gatewaypassword;

    GtkEntry *eGroup, *eUsername, *eDomain, *ePassword1, *ePassword2;
    GtkEntry *eGatewayUsername, *eGatewayDomain, *eGatewayPassword1, *eGatewayPassword2;
    GtkListStore* store;
    GtkDialog* dialog;
    GtkTreeView* table;
    GtkButton* btnDoChange;
    GtkLabel* statusLabel;

    GtkTreeIter iter;
    int changed_passwords_count;
    guint sid;
    guint searchentrychange_timeout_source_id;
};

enum {
    COL_F = 0,
    COL_NAME,
    COL_GROUP,
    COL_USERNAME,
    COL_GATEWAY_USERNAME,
    COL_FILENAME,
    NUM_COLS
};

static gboolean remmina_mpchange_fieldcompare(const gchar *needle, const gchar *haystack, int *matchcount)
{
    TRACE_CALL(__func__);

    if (needle[0] == 0) {
        (*matchcount)++;
        return TRUE;
    }

    if (haystack[0] == 0 || strstr(haystack, needle) == NULL){
        return FALSE;
    }
    
    (*matchcount)++;
    return TRUE;

}

static void remmina_mpchange_file_list_callback(RemminaFile *remminafile, gpointer user_data)
{
    TRACE_CALL(__func__);
    GtkListStore* store;
    GtkTreeIter iter;
    int matchcount;
    const gchar *username, *domain, *group, *gatewayusername, *gatewaydomain;

    gchar* s;
    gchar* t;
    struct mpchanger_params* mpcp;

    mpcp = (struct mpchanger_params*)user_data;
    store = GTK_LIST_STORE(mpcp->store);


    username = remmina_file_get_string(remminafile, "username");
    domain = remmina_file_get_string(remminafile, "domain");
    group = remmina_file_get_string(remminafile, "group");
    gatewayusername = remmina_file_get_string(remminafile, "gateway_username");
    gatewaydomain = remmina_file_get_string(remminafile, "gateway_domain");

    if (username == NULL)
        username = "";

    if (domain == NULL)
        domain = "";

    if (group == NULL)
        group = "";

    if (gatewayusername == NULL)
        gatewayusername = "";

    if (gatewaydomain == NULL)
        gatewaydomain = "";

    matchcount = 0;
    if (!remmina_mpchange_fieldcompare(mpcp->username, username, &matchcount))
        return;
    if (!remmina_mpchange_fieldcompare(mpcp->domain, domain, &matchcount))
        return;
    if (!remmina_mpchange_fieldcompare(mpcp->group, group, &matchcount))
        return;
    if (!remmina_mpchange_fieldcompare(mpcp->gatewayusername, gatewayusername, &matchcount))
        return;
    if (!remmina_mpchange_fieldcompare(mpcp->gatewaydomain, gatewaydomain, &matchcount))
        return;

    gtk_list_store_append(store, &iter);
    s = g_strdup_printf("%s\\%s", domain, username);
    t = g_strdup_printf("%s\\%s", gatewaydomain, gatewayusername);
    gtk_list_store_set(store, &iter,
        COL_F, matchcount >= 5 ? TRUE : FALSE,
        COL_NAME, remmina_file_get_string(remminafile, "name"),
        COL_GROUP, group,
        COL_USERNAME,   s,
        COL_GATEWAY_USERNAME,   t,
        COL_FILENAME, remminafile->filename,
        -1);
    g_free(s);
    g_free(t);

}

static void remmina_mpchange_checkbox_toggle(GtkCellRendererToggle *cell, gchar *path_string, gpointer user_data)
{
    TRACE_CALL(__func__);
    GtkTreeIter iter;
    struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
    GtkTreePath *path;

    gboolean a = gtk_cell_renderer_toggle_get_active(cell);
    path = gtk_tree_path_new_from_string(path_string);
    gtk_tree_model_get_iter(GTK_TREE_MODEL(mpcp->store), &iter, path);
    gtk_tree_path_free(path);
    gtk_list_store_set(mpcp->store, &iter, COL_F, !a, -1);
}

static void remmina_mpchange_dochange(gchar* fname, struct mpchanger_params* mpcp)
{
    TRACE_CALL(__func__);

    RemminaFile* remminafile;

    remminafile = remmina_file_load(fname);
    if (remminafile) {
        if(mpcp->password[0] != 0){
            remmina_file_store_secret_plugin_password(remminafile, "password", mpcp->password);
        }
        if(mpcp->gatewaypassword[0] != 0){
            remmina_file_store_secret_plugin_password(remminafile, "gateway_password", mpcp->gatewaypassword);
        }
        remmina_file_free(remminafile);
        mpcp->changed_passwords_count++;
    }

}

static void enable_inputs(struct mpchanger_params* mpcp, gboolean ena)
{
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGroup), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eUsername), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eDomain), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->ePassword1), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->ePassword2), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayUsername), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayDomain), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayPassword1), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayPassword2), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->btnDoChange), ena);
    gtk_widget_set_sensitive(GTK_WIDGET(mpcp->table), ena);
}

static gboolean changenext(gpointer user_data)
{
    TRACE_CALL(__func__);
    struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
    gchar* fname;
    gboolean sel;

    gtk_tree_model_get(GTK_TREE_MODEL(mpcp->store), &mpcp->iter, COL_F, &sel, -1);
    gtk_tree_model_get(GTK_TREE_MODEL(mpcp->store), &mpcp->iter, COL_FILENAME, &fname, -1);
    if (sel) {
        remmina_mpchange_dochange(fname, mpcp);
    }
    g_free(fname);

    if (gtk_tree_model_iter_next(GTK_TREE_MODEL(mpcp->store), &mpcp->iter)) {
        return G_SOURCE_CONTINUE;
    }else  {
        gtk_dialog_response(mpcp->dialog, 1);
        mpcp->sid = 0;
        return G_SOURCE_REMOVE;
    }
}

static void remmina_mpchange_dochange_clicked(GtkButton *btn, gpointer user_data)
{
    TRACE_CALL(__func__);
    struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
    const gchar *passwd1, *passwd2, *gatewaypasswd1, *gatewaypasswd2;

    if (mpcp->searchentrychange_timeout_source_id) {
        g_source_remove(mpcp->searchentrychange_timeout_source_id);
        mpcp->searchentrychange_timeout_source_id = 0;
    }

    if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(mpcp->store), &mpcp->iter))
        return;

    passwd1 = gtk_entry_get_text(mpcp->ePassword1);
    passwd2 = gtk_entry_get_text(mpcp->ePassword2);

    if (g_strcmp0(passwd1, passwd2) != 0) {
        GtkWidget *msgDialog;
        msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
            GTK_DIALOG_DESTROY_WITH_PARENT,
            GTK_MESSAGE_ERROR,
            GTK_BUTTONS_CLOSE,
            _("The passwords do not match"));
        gtk_dialog_run(GTK_DIALOG(msgDialog));
        gtk_widget_destroy(msgDialog);
        return;
    }
    gatewaypasswd1 = gtk_entry_get_text(mpcp->eGatewayPassword1);
    gatewaypasswd2 = gtk_entry_get_text(mpcp->eGatewayPassword2);
    if (g_strcmp0(gatewaypasswd1, gatewaypasswd2) != 0) {
        GtkWidget *msgDialog;
        msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
            GTK_DIALOG_DESTROY_WITH_PARENT,
            GTK_MESSAGE_ERROR,
            GTK_BUTTONS_CLOSE,
            _("The Gateway passwords do not match"));
        gtk_dialog_run(GTK_DIALOG(msgDialog));
        gtk_widget_destroy(msgDialog);
        return;
    }

    g_free(mpcp->password);
    mpcp->password = g_strdup(passwd1);
    mpcp->changed_passwords_count = 0;

    g_free(mpcp->gatewaypassword);
    mpcp->gatewaypassword = g_strdup(gatewaypasswd1);
    mpcp->changed_passwords_count = 0;

    gtk_label_set_text(mpcp->statusLabel, _("Resetting passwords, please wait…"));

    enable_inputs(mpcp, FALSE);
    mpcp->sid = g_idle_add(changenext, (gpointer)mpcp);

}

static gboolean remmina_mpchange_searchfield_changed_to(gpointer user_data)
{
    TRACE_CALL(__func__);
    struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;
    const gchar *s;

    if (mpcp->searchentrychange_timeout_source_id) {
        g_source_remove(mpcp->searchentrychange_timeout_source_id);
        mpcp->searchentrychange_timeout_source_id = 0;
    }

    s = gtk_entry_get_text(mpcp->eGroup);
    g_free(mpcp->group);
    mpcp->group = g_strdup(s);

    s = gtk_entry_get_text(mpcp->eDomain);
    g_free(mpcp->domain);
    mpcp->domain = g_strdup(s);

    s = gtk_entry_get_text(mpcp->eUsername);
    g_free(mpcp->username);
    mpcp->username = g_strdup(s);

    s = gtk_entry_get_text(mpcp->eGatewayDomain);
    g_free(mpcp->gatewaydomain);
    mpcp->gatewaydomain = g_strdup(s);

    s = gtk_entry_get_text(mpcp->eGatewayUsername);
    g_free(mpcp->gatewayusername);
    mpcp->gatewayusername = g_strdup(s);

    if (mpcp->store != NULL) {
        gtk_tree_view_set_model(mpcp->table, NULL);
    }
    mpcp->store = gtk_list_store_new(NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);

    if (mpcp->group[0] != 0 || mpcp->domain[0] != 0 || mpcp->username[0] != 0 || mpcp->gatewayusername[0] != 0 || mpcp->gatewaydomain[0] != 0)
        remmina_file_manager_iterate((GFunc)remmina_mpchange_file_list_callback, (gpointer)mpcp);

    gtk_tree_view_set_model(mpcp->table, GTK_TREE_MODEL(mpcp->store));

    return G_SOURCE_CONTINUE;       // Source already remove at the beginning

}

static void remmina_mpchange_searchfield_changed(GtkSearchEntry *se, gpointer user_data)
{
    TRACE_CALL(__func__);
    struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;

    if (mpcp->searchentrychange_timeout_source_id) {
        g_source_remove(mpcp->searchentrychange_timeout_source_id);
        mpcp->searchentrychange_timeout_source_id = 0;
    }

    mpcp->searchentrychange_timeout_source_id = g_timeout_add(500, remmina_mpchange_searchfield_changed_to, user_data);
}


static void remmina_mpchange_stopsearch(GtkSearchEntry *entry, gpointer user_data)
{
    TRACE_CALL(__func__);
    /* The stop-search signal is emitted when pressing Esc on a GtkSearchEntry. We end the dialog. */
    struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;
    gtk_dialog_response(mpcp->dialog, 1);
}

static gboolean remmina_file_multipasswd_changer_mt(gpointer d)
{
    TRACE_CALL(__func__);
    struct mpchanger_params *mpcp = d;
    GtkBuilder* bu;
    GtkDialog* dialog;
    GtkWindow* mainwindow;
    GtkCellRendererToggle *toggle;
    RemminaSecretPlugin *secret_plugin;
    char *initerror;

    mainwindow = remmina_main_get_window();

    /* The multiple password changer works only when a secrecy plugin is available */
    initerror = NULL;
    secret_plugin = remmina_plugin_manager_get_secret_plugin();
    if (secret_plugin == NULL) {
        initerror = _("The multi password changer requires a secrecy plugin.\n");
    }else {
        if (!secret_plugin->is_service_available(secret_plugin)) {
            initerror = _("The multi password changer requires a secrecy service.\n");
        }
    }
    if (initerror) {
        GtkWidget *msgDialog;
        msgDialog = gtk_message_dialog_new(mainwindow, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
            "%s", initerror);
        gtk_dialog_run(GTK_DIALOG(msgDialog));
        gtk_widget_destroy(msgDialog);
        return FALSE;
    }


    bu = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_mpc.glade");
    if (!bu) {
        REMMINA_DEBUG("Unable to load the multiple password changer Glade file interface\n");
        return FALSE;
    }

    dialog = GTK_DIALOG(gtk_builder_get_object(bu, "MPCDialog"));
    mpcp->dialog = dialog;
    if (mainwindow)
        gtk_window_set_transient_for(GTK_WINDOW(dialog), mainwindow);


    mpcp->eGroup = GTK_ENTRY(GET_DIALOG_OBJECT("groupEntry"));
    gtk_entry_set_text(mpcp->eGroup, mpcp->group);
    g_signal_connect(G_OBJECT(mpcp->eGroup), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
    g_signal_connect(G_OBJECT(mpcp->eGroup), "stop-search", G_CALLBACK(remmina_mpchange_stopsearch), (gpointer)mpcp);

    mpcp->eUsername = GTK_ENTRY(GET_DIALOG_OBJECT("usernameEntry"));
    gtk_entry_set_text(mpcp->eUsername, mpcp->username);
    g_signal_connect(G_OBJECT(mpcp->eUsername), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);

    mpcp->eGatewayUsername = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayUsernameEntry"));
    gtk_entry_set_text(mpcp->eGatewayUsername, mpcp->gatewayusername);
    g_signal_connect(G_OBJECT(mpcp->eGatewayUsername), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);

    mpcp->eDomain = GTK_ENTRY(GET_DIALOG_OBJECT("domainEntry"));
    gtk_entry_set_text(mpcp->eDomain, mpcp->domain);
    g_signal_connect(G_OBJECT(mpcp->eDomain), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);

    mpcp->eGatewayDomain = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayDomainEntry"));
    gtk_entry_set_text(mpcp->eGatewayDomain, mpcp->gatewaydomain);
    g_signal_connect(G_OBJECT(mpcp->eGatewayDomain), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);

    mpcp->ePassword1 = GTK_ENTRY(GET_DIALOG_OBJECT("password1Entry"));
    gtk_entry_set_text(mpcp->ePassword1, mpcp->password);

    mpcp->eGatewayPassword1 = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayPassword1Entry"));
    gtk_entry_set_text(mpcp->eGatewayPassword1, mpcp->gatewaypassword);

    mpcp->ePassword2 = GTK_ENTRY(GET_DIALOG_OBJECT("password2Entry"));
    gtk_entry_set_text(mpcp->ePassword2, mpcp->password);

    mpcp->eGatewayPassword2 = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayPassword2Entry"));
    gtk_entry_set_text(mpcp->eGatewayPassword2, mpcp->gatewaypassword);

    mpcp->statusLabel = GTK_LABEL(GET_DIALOG_OBJECT("statusLabel"));
    



    mpcp->store = NULL;

    mpcp->table = GTK_TREE_VIEW(GET_DIALOG_OBJECT("profchangelist"));

    /* Fire a fake searchfield changed, so a new list store is created */
    remmina_mpchange_searchfield_changed(NULL, (gpointer)mpcp);

    toggle = GTK_CELL_RENDERER_TOGGLE(GET_DIALOG_OBJECT("cellrenderertoggle1"));
    g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(remmina_mpchange_checkbox_toggle), (gpointer)mpcp);

    mpcp->btnDoChange = GTK_BUTTON(GET_DIALOG_OBJECT("btnDoChange"));
    g_signal_connect(mpcp->btnDoChange, "clicked", G_CALLBACK(remmina_mpchange_dochange_clicked), (gpointer)mpcp);

    gtk_dialog_run(dialog);
    gtk_widget_destroy(GTK_WIDGET(dialog));

    if (mpcp->sid) {
        g_source_remove(mpcp->sid);
        mpcp->sid = 0;
    }

    if (mpcp->searchentrychange_timeout_source_id) {
        g_source_remove(mpcp->searchentrychange_timeout_source_id);
        mpcp->searchentrychange_timeout_source_id = 0;
    }

    if (mpcp->changed_passwords_count) {
        GtkWidget *msgDialog;
        msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
            GTK_DIALOG_DESTROY_WITH_PARENT,
            GTK_MESSAGE_INFO,
            GTK_BUTTONS_OK,
            ngettext("%d password changed.", "%d passwords changed.", mpcp->changed_passwords_count), mpcp->changed_passwords_count);
        gtk_dialog_run(GTK_DIALOG(msgDialog));
        gtk_widget_destroy(msgDialog);
    }

    // Free data
    g_free(mpcp->username);
    g_free(mpcp->password);
    g_free(mpcp->domain);
    g_free(mpcp->group);
    g_free(mpcp->gatewayusername);
    g_free(mpcp->gatewaypassword);
    g_free(mpcp->gatewaydomain);
    g_free(mpcp);
    return FALSE;
}


void
remmina_mpchange_schedule(gboolean has_domain, const gchar *group, const gchar *domain, const gchar *username, const gchar *password, const gchar *gatewayusername, const gchar *gatewaydomain, const gchar *gatewaypassword)
{
    // We could also be called in a subthread after a successful connection
    // (not currently implemented)
    // So we just schedule the multipassword changer to be executed on
    // the main thread

    TRACE_CALL(__func__);
    struct mpchanger_params *mpcp;

    mpcp = g_malloc0(sizeof(struct mpchanger_params));
    mpcp->username = g_strdup(username);
    mpcp->password = g_strdup(password);
    mpcp->domain = g_strdup(domain);
    mpcp->group = g_strdup(group);
    mpcp->gatewayusername = g_strdup(gatewayusername);
    mpcp->gatewaypassword = g_strdup(gatewaypassword);
    mpcp->gatewaydomain = g_strdup(gatewaydomain);
    gdk_threads_add_idle(remmina_file_multipasswd_changer_mt, (gpointer)mpcp);

}