fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-01-21 00:10:28 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/libnm/tests/test-secret-agent.c
Thomas Haller 52dbab7d07 all: use nm_clear_pointer() instead of g_clear_pointer() 
g_clear_pointer() would always cast the destroy notify function
pointer to GDestroyNotify. That means, it lost some type safety, like

   GPtrArray *ptr_arr = ...

   g_clear_pointer (&ptr_arr, g_array_unref);

Since glib 2.58 ([1]), g_clear_pointer() is also more type safe. But
this is not used by NetworkManager, because we don't set
GLIB_VERSION_MIN_REQUIRED to 2.58.

[1] f9a9902aac

We have nm_clear_pointer() to avoid this issue for a long time (pre
1.12.0). Possibly we should redefine in our source tree g_clear_pointer()
as nm_clear_pointer(). However, I don't like to patch glib functions
with our own variant. Arguably, we do patch g_clear_error() in
such a manner. But there the point is to make the function inlinable.

Also, nm_clear_pointer() returns a boolean that indicates whether
anything was cleared. That is sometimes useful. I think we should
just consistently use nm_clear_pointer() instead, which does always
the preferable thing.

Replace:

   sed 's/\<g_clear_pointer *(\([^;]*\), *\([a-z_A-Z0-9]\+\) *)/nm_clear_pointer (\1, \2)/g' $(git grep -l g_clear_pointer) -i
2020-03-23 11:22:38 +01:00

740 lines
24 KiB
C
Raw Blame History

// 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 ();
}
Reference in a new issue View git blame Copy permalink