/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2010 - 2014 Red Hat, Inc.
*/
#include "libnm/nm-default-libnm.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();
}