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

/*

 * Copyright (C) 2010 - 2014 Red Hat, Inc.

 */

#include "nm-default.h"

#include <sys/types.h>

#include <signal.h>

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

#include "nm-test-libnm-utils.h"

/*****************************************************************************/

enum {

    SECRET_REQUESTED,

    LAST_SIGNAL,

};

static guint signals[LAST_SIGNAL] = {0};

typedef NMSecretAgentOld      TestSecretAgent;

typedef NMSecretAgentOldClass TestSecretAgentClass;

GType test_secret_agent_get_type(void);

G_DEFINE_TYPE(TestSecretAgent, test_secret_agent, NM_TYPE_SECRET_AGENT_OLD)

static void

test_secret_agent_get_secrets(NMSecretAgentOld *             agent,

                              NMConnection *                 connection,

                              const char *                   connection_path,

                              const char *                   setting_name,

                              const char **                  hints,

                              NMSecretAgentGetSecretsFlags   flags,

                              NMSecretAgentOldGetSecretsFunc callback,

                              gpointer                       callback_data)

{

    NMSettingWirelessSecurity *s_wsec;

    GVariant *                 secrets = NULL;

    GVariantBuilder            secrets_builder, setting_builder;

    char *                     secret = NULL;

    GError *                   error  = NULL;

    g_assert_cmpstr(setting_name, ==, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME);

    s_wsec = nm_connection_get_setting_wireless_security(connection);

    g_assert(s_wsec);

    g_assert_cmpstr(nm_setting_wireless_security_get_key_mgmt(s_wsec), ==, "wpa-psk");

    g_assert_cmpstr(nm_setting_wireless_security_get_psk(s_wsec), ==, NULL);

    g_signal_emit(agent,

                  signals[SECRET_REQUESTED],

                  0,

                  connection,

                  connection_path,

                  NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,

                  NM_SETTING_WIRELESS_SECURITY_PSK,

                  &secret);

    if (!secret) {

        error = g_error_new(NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_NO_SECRETS, "No secrets");

        goto done;

    }

    if (!strcmp(secret, "CANCEL")) {

        error = g_error_new(NM_SECRET_AGENT_ERROR,

                            NM_SECRET_AGENT_ERROR_USER_CANCELED,

                            "User canceled");

        goto done;

    }

    g_variant_builder_init(&setting_builder, NM_VARIANT_TYPE_SETTING);

    g_variant_builder_add(&setting_builder,

                          "{sv}",

                          NM_SETTING_WIRELESS_SECURITY_PSK,

                          g_variant_new_string(secret));

    g_variant_builder_init(&secrets_builder, NM_VARIANT_TYPE_CONNECTION);

    g_variant_builder_add(&secrets_builder, "{sa{sv}}", setting_name, &setting_builder);

    secrets = g_variant_ref_sink(g_variant_builder_end(&secrets_builder));

done:

    callback(agent, connection, secrets, error, callback_data);

    g_clear_error(&error);

    nm_clear_pointer(&secrets, g_variant_unref);

    g_free(secret);

}

static void

test_secret_agent_cancel_get_secrets(NMSecretAgentOld *agent,

                                     const char *      connection_path,

                                     const char *      setting_name)

{

    g_assert_not_reached();

}

static void

test_secret_agent_save_secrets(NMSecretAgentOld *              agent,

                               NMConnection *                  connection,

                               const char *                    connection_path,

                               NMSecretAgentOldSaveSecretsFunc callback,

                               gpointer                        callback_data)

{

    g_assert_not_reached();

}

static void

test_secret_agent_delete_secrets(NMSecretAgentOld *                agent,

                                 NMConnection *                    connection,

                                 const char *                      connection_path,

                                 NMSecretAgentOldDeleteSecretsFunc callback,

                                 gpointer                          callback_data)

{

    g_assert_not_reached();

}

static void

test_secret_agent_init(TestSecretAgent *agent)

{}

static NMSecretAgentOld *

test_secret_agent_new(gboolean auto_register)

{

    return nmtstc_context_object_new(test_secret_agent_get_type(),

                                     TRUE,

                                     NM_SECRET_AGENT_OLD_IDENTIFIER,

                                     "test-secret-agent",

                                     NM_SECRET_AGENT_OLD_AUTO_REGISTER,

                                     auto_register,

                                     NULL);

}

static void

test_secret_agent_class_init(TestSecretAgentClass *klass)

{

    GObjectClass *         object_class = G_OBJECT_CLASS(klass);

    NMSecretAgentOldClass *agent_class  = NM_SECRET_AGENT_OLD_CLASS(klass);

    agent_class->get_secrets        = test_secret_agent_get_secrets;

    agent_class->cancel_get_secrets = test_secret_agent_cancel_get_secrets;

    agent_class->save_secrets       = test_secret_agent_save_secrets;

    agent_class->delete_secrets     = test_secret_agent_delete_secrets;

    signals[SECRET_REQUESTED] = g_signal_new("secret-requested",

                                             G_OBJECT_CLASS_TYPE(object_class),

                                             G_SIGNAL_RUN_LAST,

                                             0,

                                             NULL,

                                             NULL,

                                             NULL,

                                             G_TYPE_STRING,

                                             4,

                                             NM_TYPE_CONNECTION,

                                             G_TYPE_STRING,

                                             G_TYPE_STRING,

                                             G_TYPE_STRING);

}

/*****************************************************************************/

typedef struct {

    NMTstcServiceInfo *sinfo;

    NMClient *         client;

    NMSecretAgentOld *agent;

    NMDevice *        device;

    NMConnection *    connection;

    GMainLoop *loop;

    GSource *  timeout_source;

    char *ifname;

    char *con_id;

    int secrets_requested;

} TestSecretAgentData;

static void

connection_added_cb(GObject *s, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata = user_data;

    NMRemoteConnection * connection;

    GError *             error = NULL;

    connection = nm_client_add_connection_finish(sadata->client, result, &error);

    g_assert_no_error(error);

    g_assert_cmpstr(nm_connection_get_id(NM_CONNECTION(connection)), ==, sadata->con_id);

    sadata->connection = NM_CONNECTION(connection);

    g_main_loop_quit(sadata->loop);

}

static void

register_cb(GObject *object, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata = user_data;

    GError *             error  = NULL;

    nm_secret_agent_old_register_finish(sadata->agent, result, &error);

    g_assert_no_error(error);

    g_assert(nm_secret_agent_old_get_registered(sadata->agent));

    g_main_loop_quit(sadata->loop);

}

#define TEST_CON_ID_PREFIX "test-secret-agent"

static void

test_setup(TestSecretAgentData *sadata, gconstpointer test_data)

{

    static int           static_counter = 0;

    const int            counter        = static_counter++;

    const char *         create_agent   = test_data;

    NMConnection *       connection;

    NMSettingConnection *s_con;

    NMSettingWireless *  s_wireless;

    GBytes *             ssid;

    NMSetting *          s_wsec;

    gs_free_error GError *error = NULL;

    sadata->sinfo = nmtstc_service_init();

    if (!sadata->sinfo)

        return;

    g_assert(nm_g_main_context_is_thread_default(NULL));

    sadata->client = nmtstc_client_new(TRUE);

    g_assert(nm_g_main_context_is_thread_default(NULL));

    g_assert(nm_g_main_context_is_thread_default(nm_client_get_main_context(sadata->client)));

    sadata->loop = g_main_loop_new(NULL, FALSE);

    sadata->timeout_source = g_timeout_source_new_seconds(5);

    g_source_set_callback(sadata->timeout_source, nmtst_g_source_assert_not_called, NULL, NULL);

    g_source_attach(sadata->timeout_source, NULL);

    sadata->ifname = g_strdup_printf("wlan%d", counter);

    sadata->con_id = g_strdup_printf("%s-%d", TEST_CON_ID_PREFIX, counter);

    sadata->device =

        nmtstc_service_add_device(sadata->sinfo, sadata->client, "AddWifiDevice", sadata->ifname);

    /* Create the connection */

    connection = nmtst_create_minimal_connection(sadata->con_id,

                                                 NULL,

                                                 NM_SETTING_WIRELESS_SETTING_NAME,

                                                 &s_con);

    g_object_set(s_con, NM_SETTING_CONNECTION_INTERFACE_NAME, sadata->ifname, NULL);

    s_wireless = nm_connection_get_setting_wireless(connection);

    ssid       = g_bytes_new("foo", 3);

    g_object_set(s_wireless, NM_SETTING_WIRELESS_SSID, ssid, NULL);

    g_bytes_unref(ssid);

    s_wsec = g_object_new(NM_TYPE_SETTING_WIRELESS_SECURITY,

                          NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                          "wpa-psk",

                          NULL);

    nm_connection_add_setting(connection, s_wsec);

    nm_client_add_connection_async(sadata->client,

                                   connection,

                                   TRUE,

                                   NULL,

                                   connection_added_cb,

                                   sadata);

    g_object_unref(connection);

    g_main_loop_run(sadata->loop);

    g_assert(sadata->connection);

    if (nm_streq(create_agent, "1")) {

        gboolean auto_register = nmtst_get_rand_bool();

        sadata->agent = test_secret_agent_new(auto_register);

        if (auto_register) {

            g_assert(nm_secret_agent_old_get_registered(sadata->agent));

            nm_secret_agent_old_register(sadata->agent, NULL, &error);

            g_assert_no_error(error);

        } else {

            g_assert(!nm_secret_agent_old_get_registered(sadata->agent));

            nm_secret_agent_old_register_async(sadata->agent, NULL, register_cb, sadata);

            g_main_loop_run(sadata->loop);

        }

        g_assert(nm_secret_agent_old_get_registered(sadata->agent));

    }

}

static void

test_cleanup(TestSecretAgentData *sadata, gconstpointer test_data)

{

    GVariant *                  ret;

    GError *                    error        = NULL;

    NMTstContextBusyWatcherData watcher_data = {};

    g_assert(nm_g_main_context_is_thread_default(NULL));

    if (!sadata->sinfo)

        return;

    g_assert(nm_g_main_context_is_thread_default(nm_client_get_main_context(sadata->client)));

    nmtst_context_busy_watcher_add(&watcher_data,

                                   nm_client_get_context_busy_watcher(sadata->client));

    if (sadata->agent) {

        nmtst_context_busy_watcher_add(&watcher_data,

                                       nm_secret_agent_old_get_context_busy_watcher(sadata->agent));

        if (nm_secret_agent_old_get_registered(sadata->agent)) {

            nm_secret_agent_old_unregister(sadata->agent, NULL, &error);

            g_assert_no_error(error);

        }

        g_object_unref(sadata->agent);

    }

    ret =

        g_dbus_proxy_call_sync(sadata->sinfo->proxy,

                               "RemoveDevice",

                               g_variant_new("(s)", nm_object_get_path(NM_OBJECT(sadata->device))),

                               G_DBUS_CALL_FLAGS_NO_AUTO_START,

                               3000,

                               NULL,

                               &error);

    g_assert_no_error(error);

    g_variant_unref(ret);

    g_object_unref(sadata->connection);

    g_object_unref(sadata->client);

    nmtstc_service_cleanup(sadata->sinfo);

    nm_clear_g_source_inst(&sadata->timeout_source);

    g_main_loop_unref(sadata->loop);

    g_free(sadata->ifname);

    g_free(sadata->con_id);

    *sadata = (TestSecretAgentData){};

    nmtst_context_busy_watcher_wait(&watcher_data);

    while (g_main_context_iteration(NULL, FALSE)) {}

    nmtst_main_context_assert_no_dispatch(NULL, nmtst_get_rand_uint32() % 500);

}

/*****************************************************************************/

static void

connection_activated_none_cb(GObject *c, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata = user_data;

    gs_free_error GError *error = NULL;

    nm_client_activate_connection_finish(sadata->client, result, &error);

    g_assert_error(error, NM_AGENT_MANAGER_ERROR, NM_AGENT_MANAGER_ERROR_NO_SECRETS);

    g_main_loop_quit(sadata->loop);

}

static void

test_secret_agent_none(TestSecretAgentData *sadata, gconstpointer test_data)

{

    if (!nmtstc_service_available(sadata->sinfo))

        return;

    nm_client_activate_connection_async(sadata->client,

                                        sadata->connection,

                                        sadata->device,

                                        NULL,

                                        NULL,

                                        connection_activated_none_cb,

                                        sadata);

    g_main_loop_run(sadata->loop);

}

/*****************************************************************************/

static char *

secrets_requested_no_secrets_cb(TestSecretAgent *agent,

                                NMConnection *   connection,

                                const char *     connection_path,

                                const char *     setting_name,

                                const char *     secret_name,

                                gpointer         user_data)

{

    TestSecretAgentData *sadata = user_data;

    g_assert_cmpstr(connection_path, ==, nm_connection_get_path(sadata->connection));

    sadata->secrets_requested++;

    return NULL;

}

static void

connection_activated_no_secrets_cb(GObject *c, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata            = user_data;

    gs_unref_object NMActiveConnection *ac = NULL;

    gs_free_error GError *error            = NULL;

    ac = nm_client_activate_connection_finish(sadata->client, result, &error);

    g_assert_error(error, NM_AGENT_MANAGER_ERROR, NM_AGENT_MANAGER_ERROR_NO_SECRETS);

    g_main_loop_quit(sadata->loop);

}

static void

test_secret_agent_no_secrets(TestSecretAgentData *sadata, gconstpointer test_data)

{

    if (!nmtstc_service_available(sadata->sinfo))

        return;

    g_signal_connect(sadata->agent,

                     "secret-requested",

                     G_CALLBACK(secrets_requested_no_secrets_cb),

                     sadata);

    nm_client_activate_connection_async(sadata->client,

                                        sadata->connection,

                                        sadata->device,

                                        NULL,

                                        NULL,

                                        connection_activated_no_secrets_cb,

                                        sadata);

    g_main_loop_run(sadata->loop);

    g_assert_cmpint(sadata->secrets_requested, ==, 1);

}

/*****************************************************************************/

static void

connection_activated_cancel_cb(GObject *c, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata            = user_data;

    gs_unref_object NMActiveConnection *ac = NULL;

    gs_free_error GError *error            = NULL;

    ac = nm_client_activate_connection_finish(sadata->client, result, &error);

    g_assert_error(error, NM_AGENT_MANAGER_ERROR, NM_AGENT_MANAGER_ERROR_USER_CANCELED);

    g_main_loop_quit(sadata->loop);

}

static char *

secrets_requested_cancel_cb(TestSecretAgent *agent,

                            NMConnection *   connection,

                            const char *     connection_path,

                            const char *     setting_name,

                            const char *     secret_name,

                            gpointer         user_data)

{

    TestSecretAgentData *sadata = user_data;

    g_assert_cmpstr(connection_path, ==, nm_connection_get_path(sadata->connection));

    sadata->secrets_requested++;

    return g_strdup("CANCEL");

}

static void

test_secret_agent_cancel(TestSecretAgentData *sadata, gconstpointer test_data)

{

    if (!nmtstc_service_available(sadata->sinfo))

        return;

    g_signal_connect(sadata->agent,

                     "secret-requested",

                     G_CALLBACK(secrets_requested_cancel_cb),

                     sadata);

    nm_client_activate_connection_async(sadata->client,

                                        sadata->connection,

                                        sadata->device,

                                        NULL,

                                        NULL,

                                        connection_activated_cancel_cb,

                                        sadata);

    g_main_loop_run(sadata->loop);

    g_assert_cmpint(sadata->secrets_requested, ==, 1);

}

/*****************************************************************************/

static void

connection_activated_good_cb(GObject *c, GAsyncResult *result, gpointer user_data)

{

    TestSecretAgentData *sadata = user_data;

    NMActiveConnection * ac;

    GError *             error = NULL;

    ac = nm_client_activate_connection_finish(sadata->client, result, &error);

    g_assert_no_error(error);

    g_object_unref(ac);

    g_main_loop_quit(sadata->loop);

}

static char *

secrets_requested_good_cb(TestSecretAgent *agent,

                          NMConnection *   connection,

                          const char *     connection_path,

                          const char *     setting_name,

                          const char *     secret_name,

                          gpointer         user_data)

{

    TestSecretAgentData *sadata = user_data;

    g_assert_cmpstr(connection_path, ==, nm_connection_get_path(sadata->connection));

    sadata->secrets_requested++;

    return g_strdup("password");

}

static void

test_secret_agent_good(TestSecretAgentData *sadata, gconstpointer test_data)

{

    if (!nmtstc_service_available(sadata->sinfo))

        return;

    g_signal_connect(sadata->agent,

                     "secret-requested",

                     G_CALLBACK(secrets_requested_good_cb),

                     sadata);

    nm_client_activate_connection_async(sadata->client,

                                        sadata->connection,

                                        sadata->device,

                                        NULL,

                                        NULL,

                                        connection_activated_good_cb,

                                        sadata);

    g_main_loop_run(sadata->loop);

    g_assert_cmpint(sadata->secrets_requested, ==, 1);

}

/*****************************************************************************/

static void

async_init_cb(GObject *object, GAsyncResult *result, gpointer user_data)

{

    GMainLoop *   loop             = user_data;

    gs_free_error GError *error    = NULL;

    gs_unref_object GObject *agent = NULL;

    agent = g_async_initable_new_finish(G_ASYNC_INITABLE(object), result, &error);

    nmtst_assert_success(NM_IS_SECRET_AGENT_OLD(agent), error);

    g_assert(!nm_secret_agent_old_get_registered(NM_SECRET_AGENT_OLD(agent)));

    g_main_loop_quit(loop);

}

static void

test_secret_agent_nm_not_running(void)

{

    gs_unref_object NMSecretAgentOld *agent  = NULL;

    nm_auto_unref_gmainloop GMainLoop *loop  = NULL;

    GError *                           error = NULL;

    agent = g_initable_new(test_secret_agent_get_type(),

                           NULL,

                           &error,

                           NM_SECRET_AGENT_OLD_IDENTIFIER,

                           "test-secret-agent",

                           NULL);

    nmtst_assert_success(NM_IS_SECRET_AGENT_OLD(agent), error);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    g_clear_object(&agent);

    loop = g_main_loop_new(NULL, FALSE);

    g_async_initable_new_async(test_secret_agent_get_type(),

                               G_PRIORITY_DEFAULT,

                               NULL,

                               async_init_cb,

                               loop,

                               NM_SECRET_AGENT_OLD_IDENTIFIER,

                               "test-secret-agent",

                               NULL);

    g_main_loop_run(loop);

}

/*****************************************************************************/

typedef struct {

    int step;

    int invoke_count;

} AutoRegisterData;

static void

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

{

    NMSecretAgentOld *agent = NM_SECRET_AGENT_OLD(object);

    AutoRegisterData *data  = user_data;

    g_assert(data);

    g_assert(NM_IS_SECRET_AGENT_OLD(agent));

    data->invoke_count++;

    g_assert_cmpint(data->invoke_count, ==, data->step);

    switch (data->step) {

    case 1:

    case 3:

        g_assert(nm_secret_agent_old_get_registered(agent));

        break;

    case 2:

    case 4:

        g_assert(!nm_secret_agent_old_get_registered(agent));

        break;

    default:

        g_assert_not_reached();

    }

}

static void

test_secret_agent_auto_register(void)

{

    NMTstcServiceInfo *sinfo;

    gs_unref_object NMSecretAgentOld *agent              = NULL;

    GError *                          error              = NULL;

    AutoRegisterData                  auto_register_data = {

        .step         = 0,

        .invoke_count = 0,

    };

    gulong                      signal_id;

    NMTstContextBusyWatcherData watcher_data = {};

    sinfo = nmtstc_service_init();

    if (!nmtstc_service_available(sinfo))

        return;

    agent = test_secret_agent_new(FALSE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    signal_id = g_signal_connect(agent,

                                 "notify::" NM_SECRET_AGENT_OLD_REGISTERED,

                                 G_CALLBACK(registered_changed),

                                 &auto_register_data);

    if (nmtst_get_rand_bool()) {

        g_object_set(agent, NM_SECRET_AGENT_OLD_AUTO_REGISTER, TRUE, NULL);

    } else

        nm_secret_agent_old_enable(agent, TRUE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    nm_secret_agent_old_register(agent, NULL, &error);

    g_assert_no_error(error);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    auto_register_data.step = 1;

    nmtst_main_context_iterate_until_assert(NULL, 1000, nm_secret_agent_old_get_registered(agent));

    auto_register_data.step = 2;

    nm_secret_agent_old_enable(agent, FALSE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    nmtst_main_context_iterate_until(NULL, nmtst_get_rand_uint32() % 200, FALSE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    nmtstc_service_cleanup(sinfo);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    nm_secret_agent_old_enable(agent, TRUE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    nmtst_main_context_iterate_until(NULL, nmtst_get_rand_uint32() % 200, FALSE);

    g_assert(!nm_secret_agent_old_get_registered(agent));

    sinfo = nmtstc_service_init();

    g_assert(nmtstc_service_available(sinfo));

    auto_register_data.step = 3;

    nmtst_main_context_iterate_until_assert(NULL, 1000, nm_secret_agent_old_get_registered(agent));

    nmtstc_service_cleanup(sinfo);

    auto_register_data.step = 4;

    nmtst_main_context_iterate_until_assert(NULL, 1000, !nm_secret_agent_old_get_registered(agent));

    nm_clear_g_signal_handler(agent, &signal_id);

    nmtst_context_busy_watcher_add(&watcher_data,

                                   nm_secret_agent_old_get_context_busy_watcher(agent));

    g_clear_object(&agent);

    nmtst_context_busy_watcher_wait(&watcher_data);

    nmtst_main_context_assert_no_dispatch(NULL, nmtst_get_rand_uint32() % 500);

}

/*****************************************************************************/

NMTST_DEFINE();

int

main(int argc, char **argv)

{

    g_setenv("LIBNM_USE_SESSION_BUS", "1", TRUE);

    nmtst_init(&argc, &argv, TRUE);

    g_test_add("/libnm/secret-agent/none",

               TestSecretAgentData,

               "0",

               test_setup,

               test_secret_agent_none,

               test_cleanup);

    g_test_add("/libnm/secret-agent/no-secrets",

               TestSecretAgentData,

               "1",

               test_setup,

               test_secret_agent_no_secrets,

               test_cleanup);

    g_test_add("/libnm/secret-agent/cancel",

               TestSecretAgentData,

               "1",

               test_setup,

               test_secret_agent_cancel,

               test_cleanup);

    g_test_add("/libnm/secret-agent/good",

               TestSecretAgentData,

               "1",

               test_setup,

               test_secret_agent_good,

               test_cleanup);

    g_test_add_func("/libnm/secret-agent/nm-not-running", test_secret_agent_nm_not_running);

    g_test_add_func("/libnm/secret-agent/auto-register", test_secret_agent_auto_register);

    return g_test_run();

}