/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * Copyright (C) 2013 Red Hat, Inc.

 */

/**

 * SECTION:nmtui-connect

 * @short_description: nm-applet-like functionality

 *

 * nmtui-connect implements activating and deactivating #NMConnections,

 * including presenting a password dialog if necessary.

 */

#include "nm-default.h"

#include <stdlib.h>

#include "nmt-newt.h"

#include "nmtui.h"

#include "nmtui-connect.h"

#include "nmt-connect-connection-list.h"

#include "nmt-password-dialog.h"

#include "nm-secret-agent-simple.h"

#include "nm-vpn-helpers.h"

#include "nm-client-utils.h"

#include "nmt-utils.h"

/**

 * Runs openconnect to authenticate. The current screen state is saved

 * before starting the command and restored after it returns.

 */

static gboolean

openconnect_authenticate(NMConnection *connection, char **cookie, char **gateway, char **gwcert)

{

    GError *      error = NULL;

    NMSettingVpn *s_vpn;

    gboolean      ret;

    int           status = 0;

    const char *  gw, *port;

    nmt_newt_message_dialog(

        _("openconnect will be run to authenticate.\nIt will return to nmtui when completed."));

    /* Get port */

    s_vpn = nm_connection_get_setting_vpn(connection);

    gw    = nm_setting_vpn_get_data_item(s_vpn, "gateway");

    port  = gw ? strrchr(gw, ':') : NULL;

    newtSuspend();

    ret = nm_vpn_openconnect_authenticate_helper(gw, cookie, gateway, gwcert, &status, &error);

    newtResume();

    if (!ret) {

        nmt_newt_message_dialog(_("Error: openconnect failed: %s"), error->message);

        g_clear_error(&error);

        return FALSE;

    }

    if (WIFEXITED(status)) {

        if (WEXITSTATUS(status) != 0) {

            nmt_newt_message_dialog(_("openconnect failed with status %d"), WEXITSTATUS(status));

            return FALSE;

        }

    } else if (WIFSIGNALED(status)) {

        nmt_newt_message_dialog(_("openconnect failed with signal %d"), WTERMSIG(status));

        return FALSE;

    }

    if (gateway && *gateway && port) {

        char *tmp = *gateway;

        *gateway  = g_strdup_printf("%s%s", *gateway, port);

        g_free(tmp);

    }

    return TRUE;

}

static void

secrets_requested(NMSecretAgentSimple *agent,

                  const char *         request_id,

                  const char *         title,

                  const char *         msg,

                  GPtrArray *          secrets,

                  gpointer             user_data)

{

    NmtNewtForm * form;

    NMConnection *connection = NM_CONNECTION(user_data);

    int           i;

    /* Get secrets for OpenConnect VPN */

    if (connection && nm_connection_is_type(connection, NM_SETTING_VPN_SETTING_NAME)) {

        NMSettingVpn *s_vpn = nm_connection_get_setting_vpn(connection);

        if (nm_streq0(nm_setting_vpn_get_service_type(s_vpn),

                      NM_SECRET_AGENT_VPN_TYPE_OPENCONNECT)) {

            gs_free char *cookie  = NULL;

            gs_free char *gateway = NULL;

            gs_free char *gwcert  = NULL;

            openconnect_authenticate(connection, &cookie, &gateway, &gwcert);

            for (i = 0; i < secrets->len; i++) {

                NMSecretAgentSimpleSecret *secret = secrets->pdata[i];

                if (secret->secret_type != NM_SECRET_AGENT_SECRET_TYPE_VPN_SECRET)

                    continue;

                if (!nm_streq0(secret->vpn_type, NM_SECRET_AGENT_VPN_TYPE_OPENCONNECT))

                    continue;

                if (nm_streq0(secret->entry_id,

                              NM_SECRET_AGENT_ENTRY_ID_PREFX_VPN_SECRETS "cookie")) {

                    g_free(secret->value);

                    secret->value = g_steal_pointer(&cookie);

                } else if (nm_streq0(secret->entry_id,

                                     NM_SECRET_AGENT_ENTRY_ID_PREFX_VPN_SECRETS "gateway")) {

                    g_free(secret->value);

                    secret->value = g_steal_pointer(&gateway);

                } else if (nm_streq0(secret->entry_id,

                                     NM_SECRET_AGENT_ENTRY_ID_PREFX_VPN_SECRETS "gwcert")) {

                    g_free(secret->value);

                    secret->value = g_steal_pointer(&gwcert);

                }

            }

        }

    }

    form = nmt_password_dialog_new(request_id, title, msg, secrets);

    nmt_newt_form_run_sync(form);

    if (nmt_password_dialog_succeeded(NMT_PASSWORD_DIALOG(form)))

        nm_secret_agent_simple_response(agent, request_id, secrets);

    else

        nm_secret_agent_simple_response(agent, request_id, NULL);

    g_object_unref(form);

}

typedef struct {

    NMDevice *          device;

    NMActiveConnection *active;

    NmtSyncOp *         op;

} ActivateConnectionInfo;

static void

connect_cancelled(NmtNewtForm *form, gpointer user_data)

{

    ActivateConnectionInfo *info  = user_data;

    GError *                error = NULL;

    error = g_error_new_literal(G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");

    nmt_sync_op_complete_boolean(info->op, FALSE, error);

    g_clear_error(&error);

}

static void

check_activated(ActivateConnectionInfo *info)

{

    NMActiveConnectionState ac_state;

    const char *            reason = NULL;

    gs_free_error GError *error    = NULL;

    ac_state = nmc_activation_get_effective_state(info->active, info->device, &reason);

    if (!NM_IN_SET(ac_state,

                   NM_ACTIVE_CONNECTION_STATE_ACTIVATED,

                   NM_ACTIVE_CONNECTION_STATE_DEACTIVATED))

        return;

    if (ac_state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) {

        nm_assert(reason);

        error = g_error_new(NM_CLIENT_ERROR,

                            NM_CLIENT_ERROR_FAILED,

                            _("Activation failed: %s"),

                            reason);

    }

    nmt_sync_op_complete_boolean(info->op, error == NULL, error);

}

static void

activate_ac_state_changed(GObject *object, GParamSpec *pspec, gpointer user_data)

{

    check_activated(user_data);

}

static void

activate_device_state_changed(GObject *object, GParamSpec *pspec, gpointer user_data)

{

    check_activated(user_data);

}

static void

activate_callback(GObject *client, GAsyncResult *result, gpointer user_data)

{

    NmtSyncOp *         op = user_data;

    NMActiveConnection *ac;

    GError *            error = NULL;

    ac = nm_client_activate_connection_finish(NM_CLIENT(client), result, &error);

    if (error)

        nmt_sync_op_complete_pointer(op, NULL, error);

    else

        nmt_sync_op_complete_pointer(op, ac, NULL);

}

static void

add_and_activate_callback(GObject *client, GAsyncResult *result, gpointer user_data)

{

    NmtSyncOp *         op = user_data;

    NMActiveConnection *ac;

    GError *            error = NULL;

    ac = nm_client_add_and_activate_connection_finish(NM_CLIENT(client), result, &error);

    if (error)

        nmt_sync_op_complete_pointer(op, NULL, error);

    else

        nmt_sync_op_complete_pointer(op, ac, NULL);

}

static void

deactivate_connection(NMActiveConnection *ac)

{

    GError *error = NULL;

    if (!nm_client_deactivate_connection(nm_client, ac, NULL, &error)) {

        nmt_newt_message_dialog(_("Could not deactivate connection: %s"), error->message);

        g_clear_error(&error);

    }

}

static void

activate_connection(NMConnection *connection, NMDevice *device, NMObject *specific_object)

{

    NmtNewtForm *   form;

    gs_unref_object NMSecretAgentSimple *agent = NULL;

    NmtNewtWidget *                      label;

    NmtSyncOp                            op;

    const char *                         specific_object_path;

    NMActiveConnection *                 ac;

    GError *                             error = NULL;

    ActivateConnectionInfo               info  = {};

    form  = g_object_new(NMT_TYPE_NEWT_FORM, "escape-exits", TRUE, NULL);

    label = nmt_newt_label_new(_("Connecting..."));

    nmt_newt_form_set_content(form, label);

    agent = nm_secret_agent_simple_new("nmtui");

    if (agent) {

        if (connection) {

            nm_secret_agent_simple_enable(agent, nm_object_get_path(NM_OBJECT(connection)));

        }

        g_signal_connect(agent,

                         NM_SECRET_AGENT_SIMPLE_REQUEST_SECRETS,

                         G_CALLBACK(secrets_requested),

                         connection);

    }

    specific_object_path = specific_object ? nm_object_get_path(specific_object) : NULL;

    /* There's no way to cancel an nm_client_activate_connection() /

     * nm_client_add_and_activate_connection() call, so we always let them

     * complete, even if the user hits Esc; they shouldn't normally take long

     * to complete anyway.

     */

    nmt_sync_op_init(&op);

    if (connection) {

        nm_client_activate_connection_async(nm_client,

                                            connection,

                                            device,

                                            specific_object_path,

                                            NULL,

                                            activate_callback,

                                            &op);

    } else {

        nm_client_add_and_activate_connection_async(nm_client,

                                                    NULL,

                                                    device,

                                                    specific_object_path,

                                                    NULL,

                                                    add_and_activate_callback,

                                                    &op);

    }

    nmt_newt_form_show(form);

    ac = nmt_sync_op_wait_pointer(&op, &error);

    if (!ac) {

        nmt_newt_message_dialog(_("Could not activate connection: %s"), error->message);

        g_clear_error(&error);

        goto done;

    } else if (nm_active_connection_get_state(ac) == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {

        /* Already active */

        goto done;

    } else if (!nmt_newt_widget_get_realized(NMT_NEWT_WIDGET(form))) {

        /* User already hit Esc */

        goto done;

    }

    if (agent && !connection) {

        connection = NM_CONNECTION(nm_active_connection_get_connection(ac));

        if (connection) {

            nm_secret_agent_simple_enable(agent, nm_object_get_path(NM_OBJECT(connection)));

        }

    }

    /* Now wait for the connection to actually reach the ACTIVATED state,

     * allowing the user to cancel if it takes too long.

     */

    nmt_sync_op_init(&op);

    info.active = ac;

    info.device = device;

    info.op     = &op;

    g_signal_connect(form, "quit", G_CALLBACK(connect_cancelled), &info;;

    g_signal_connect(ac,

                     "notify::" NM_ACTIVE_CONNECTION_STATE,

                     G_CALLBACK(activate_ac_state_changed),

                     &info;;

    if (device) {

        g_signal_connect(device,

                         "notify::" NM_DEVICE_STATE,

                         G_CALLBACK(activate_device_state_changed),

                         &info;;

    }

    if (!nmt_sync_op_wait_boolean(&op, &error)) {

        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

            nmt_newt_message_dialog(_("Could not activate connection: %s"), error->message);

        g_clear_error(&error);

    }

    g_signal_handlers_disconnect_by_func(form, G_CALLBACK(connect_cancelled), &info;;

    g_signal_handlers_disconnect_by_func(ac, G_CALLBACK(activate_ac_state_changed), &info;;

    if (device)

        g_signal_handlers_disconnect_by_func(device,

                                             G_CALLBACK(activate_device_state_changed),

                                             &info;;

done:

    if (nmt_newt_widget_get_realized(NMT_NEWT_WIDGET(form)))

        nmt_newt_form_quit(form);

    g_object_unref(form);

    if (agent)

        nm_secret_agent_old_unregister(NM_SECRET_AGENT_OLD(agent), NULL, NULL);

}

static void

listbox_activated(NmtNewtListbox *listbox, gpointer user_data)

{

    NmtConnectConnectionList *list = NMT_CONNECT_CONNECTION_LIST(listbox);

    NMConnection *            connection;

    NMDevice *                device;

    NMObject *                specific_object;

    NMActiveConnection *      ac;

    if (!nmt_connect_connection_list_get_selection(list,

                                                   &connection,

                                                   &device,

                                                   &specific_object,

                                                   &ac))

        return;

    if (ac)

        deactivate_connection(ac);

    else

        activate_connection(connection, device, specific_object);

}

static void

activate_clicked(NmtNewtButton *button, gpointer listbox)

{

    listbox_activated(listbox, NULL);

}

static void

listbox_active_changed(GObject *object, GParamSpec *pspec, gpointer button)

{

    NmtConnectConnectionList *list = NMT_CONNECT_CONNECTION_LIST(object);

    static const char *       activate, *deactivate;

    static int                deactivate_padding, activate_padding;

    NMActiveConnection *      ac;

    gboolean                  has_selection;

    if (G_UNLIKELY(activate == NULL)) {

        int activate_width, deactivate_width;

        activate         = _("Activate");

        activate_width   = nmt_newt_text_width(activate);

        deactivate       = _("Deactivate");

        deactivate_width = nmt_newt_text_width(deactivate);

        activate_padding   = MAX(0, deactivate_width - activate_width);

        deactivate_padding = MAX(0, activate_width - deactivate_width);

    }

    has_selection = nmt_connect_connection_list_get_selection(list, NULL, NULL, NULL, &ac);

    nmt_newt_component_set_sensitive(button, has_selection);

    if (has_selection && ac) {

        nmt_newt_button_set_label(button, deactivate);

        nmt_newt_widget_set_padding(button, 0, 0, deactivate_padding, 0);

    } else {

        nmt_newt_button_set_label(button, activate);

        nmt_newt_widget_set_padding(button, 0, 0, activate_padding, 0);

    }

}

static NmtNewtForm *

nmt_connect_connection_list(gboolean is_top)

{

    int            screen_width, screen_height;

    NmtNewtForm *  form;

    NmtNewtWidget *list, *activate, *quit, *bbox, *grid;

    newtGetScreenSize(&screen_width, &screen_height);

    form = g_object_new(NMT_TYPE_NEWT_FORM,

                        "y",

                        2,

                        "height",

                        screen_height - 4,

                        "escape-exits",

                        TRUE,

                        NULL);

    grid = nmt_newt_grid_new();

    list = nmt_connect_connection_list_new();

    nmt_newt_grid_add(NMT_NEWT_GRID(grid), list, 0, 0);

    nmt_newt_grid_set_flags(NMT_NEWT_GRID(grid),

                            list,

                            NMT_NEWT_GRID_FILL_X | NMT_NEWT_GRID_FILL_Y | NMT_NEWT_GRID_EXPAND_X

                                | NMT_NEWT_GRID_EXPAND_Y);

    g_signal_connect(list, "activated", G_CALLBACK(listbox_activated), NULL);

    bbox = nmt_newt_button_box_new(NMT_NEWT_BUTTON_BOX_VERTICAL);

    nmt_newt_grid_add(NMT_NEWT_GRID(grid), bbox, 1, 0);

    nmt_newt_widget_set_padding(bbox, 1, 1, 0, 1);

    activate = nmt_newt_button_box_add_start(NMT_NEWT_BUTTON_BOX(bbox), _("Activate"));

    g_signal_connect(list, "notify::active", G_CALLBACK(listbox_active_changed), activate);

    listbox_active_changed(G_OBJECT(list), NULL, activate);

    g_signal_connect(activate, "clicked", G_CALLBACK(activate_clicked), list);

    quit = nmt_newt_button_box_add_end(NMT_NEWT_BUTTON_BOX(bbox), is_top ? _("Quit") : _("Back"));

    nmt_newt_widget_set_exit_on_activate(quit, TRUE);

    nmt_newt_form_set_content(form, grid);

    return form;

}

static NmtNewtForm *

nmt_connect_connection(const char *identifier)

{

    NmtNewtWidget *     list;

    NMConnection *      connection;

    NMDevice *          device;

    NMObject *          specific_object;

    NMActiveConnection *ac;

    list = nmt_connect_connection_list_new();

    if (!nmt_connect_connection_list_get_connection(NMT_CONNECT_CONNECTION_LIST(list),

                                                    identifier,

                                                    &connection,

                                                    &device,

                                                    &specific_object,

                                                    &ac))

        nmt_newt_message_dialog(_("No such connection '%s'"), identifier);

    else if (ac)

        nmt_newt_message_dialog(_("Connection is already active"));

    else

        activate_connection(connection, device, specific_object);

    g_object_unref(list);

    return NULL;

}

NmtNewtForm *

nmtui_connect(gboolean is_top, int argc, char **argv)

{

    if (argc == 2)

        return nmt_connect_connection(argv[1]);

    else

        return nmt_connect_connection_list(is_top);

}