mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2026-01-02 06:30:12 +01:00
494819bbbf
First note that all three provider implementations are very similar.
That is why NMCSProvider's implementation does already some work that
is common to all implementations. For example, it provides the
NMCSProviderGetConfigTaskData structure to help tracking the data of
the request.
Also note that the GCP/Azure implementations didn't handle the
cancellation correctly. They always would pass
g_task_get_cancellable(get_config_data->task)
to the asynchronous requests. That is the GCancellable provider by the
caller. That is fine when there is only one async operation ongoing. But
that is not the case, we have parallel HTTP requests.
Then, when an error happened, the overall get_config() operations fails
and the still pending requests should all be aborted. However, we must
not cancel the GCancellable of the user (because that is not owned by us).
The correct solution is to use an internal cancellable in those cases.
Anyway. Since all of this is similar, we can extend the base class
to handle things for us. This also gets the cancellation right by having
a "get_config_data->intern_cancellable".
288 lines
8.9 KiB
C
288 lines
8.9 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nmcs-provider.h"
|
|
|
|
#include "nm-cloud-setup-utils.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_HTTP_CLIENT, );
|
|
|
|
typedef struct _NMCSProviderPrivate {
|
|
NMHttpClient *http_client;
|
|
} NMCSProviderPrivate;
|
|
|
|
G_DEFINE_TYPE(NMCSProvider, nmcs_provider, G_TYPE_OBJECT);
|
|
|
|
#define NMCS_PROVIDER_GET_PRIVATE(self) _NM_GET_PRIVATE_PTR(self, NMCSProvider, NMCS_IS_PROVIDER)
|
|
|
|
/*****************************************************************************/
|
|
|
|
const char *
|
|
nmcs_provider_get_name(NMCSProvider *self)
|
|
{
|
|
NMCSProviderClass *klass;
|
|
|
|
g_return_val_if_fail(NMCS_IS_PROVIDER(self), NULL);
|
|
|
|
klass = NMCS_PROVIDER_GET_CLASS(self);
|
|
nm_assert(klass->_name);
|
|
return klass->_name;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
NMHttpClient *
|
|
nmcs_provider_get_http_client(NMCSProvider *self)
|
|
{
|
|
g_return_val_if_fail(NMCS_IS_PROVIDER(self), NULL);
|
|
|
|
return NMCS_PROVIDER_GET_PRIVATE(self)->http_client;
|
|
}
|
|
|
|
GMainContext *
|
|
nmcs_provider_get_main_context(NMCSProvider *self)
|
|
{
|
|
g_return_val_if_fail(NMCS_IS_PROVIDER(self), NULL);
|
|
|
|
return nm_http_client_get_main_context(NMCS_PROVIDER_GET_PRIVATE(self)->http_client);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
void
|
|
nmcs_provider_detect(NMCSProvider * self,
|
|
GCancellable * cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
gs_unref_object GTask *task = NULL;
|
|
const char * env;
|
|
|
|
g_return_if_fail(NMCS_IS_PROVIDER(self));
|
|
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
|
|
|
|
task = nm_g_task_new(self, cancellable, nmcs_provider_detect, callback, user_data);
|
|
|
|
nmcs_wait_for_objects_register(task);
|
|
|
|
env = g_getenv(NMCS_PROVIDER_GET_CLASS(self)->_env_provider_enabled);
|
|
if (!_nm_utils_ascii_str_to_bool(env, FALSE)) {
|
|
g_task_return_error(task,
|
|
nm_utils_error_new(NM_UTILS_ERROR_UNKNOWN, "provider is disabled"));
|
|
return;
|
|
}
|
|
|
|
NMCS_PROVIDER_GET_CLASS(self)->detect(self, g_steal_pointer(&task));
|
|
}
|
|
|
|
gboolean
|
|
nmcs_provider_detect_finish(NMCSProvider *self, GAsyncResult *result, GError **error)
|
|
{
|
|
g_return_val_if_fail(NMCS_IS_PROVIDER(self), FALSE);
|
|
g_return_val_if_fail(nm_g_task_is_valid(result, self, nmcs_provider_detect), FALSE);
|
|
|
|
return g_task_propagate_boolean(G_TASK(result), error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
NMCSProviderGetConfigIfaceData *
|
|
nmcs_provider_get_config_iface_data_new(gboolean was_requested)
|
|
{
|
|
NMCSProviderGetConfigIfaceData *iface_data;
|
|
|
|
iface_data = g_slice_new(NMCSProviderGetConfigIfaceData);
|
|
*iface_data = (NMCSProviderGetConfigIfaceData){
|
|
.iface_idx = -1,
|
|
.was_requested = was_requested,
|
|
};
|
|
return iface_data;
|
|
}
|
|
|
|
static void
|
|
_iface_data_free(gpointer data)
|
|
{
|
|
NMCSProviderGetConfigIfaceData *iface_data = data;
|
|
|
|
g_free(iface_data->ipv4s_arr);
|
|
g_free(iface_data->iproutes_arr);
|
|
|
|
nm_g_slice_free(iface_data);
|
|
}
|
|
|
|
static void
|
|
_get_config_task_maybe_return(NMCSProviderGetConfigTaskData *get_config_data, GError *error_take)
|
|
{
|
|
gs_free_error GError *error = error_take;
|
|
|
|
nm_assert(get_config_data);
|
|
nm_assert(G_IS_TASK(get_config_data->task));
|
|
|
|
if (!error) {
|
|
if (get_config_data->n_pending > 0)
|
|
return;
|
|
}
|
|
|
|
g_cancellable_cancel(get_config_data->intern_cancellable);
|
|
|
|
if (error) {
|
|
if (nm_utils_error_is_cancelled(error))
|
|
_LOGD("get-config: cancelled");
|
|
else
|
|
_LOGD("get-config: failed: %s", error->message);
|
|
g_task_return_error(get_config_data->task, g_steal_pointer(&error));
|
|
} else {
|
|
_LOGD("get-config: success");
|
|
g_task_return_pointer(get_config_data->task,
|
|
g_hash_table_ref(get_config_data->result_dict),
|
|
(GDestroyNotify) g_hash_table_unref);
|
|
}
|
|
|
|
nm_clear_g_signal_handler(g_task_get_cancellable(get_config_data->task),
|
|
&get_config_data->extern_cancelled_id);
|
|
|
|
if (get_config_data->extra_data_destroy)
|
|
get_config_data->extra_data_destroy(get_config_data->extra_data);
|
|
|
|
nm_clear_pointer(&get_config_data->result_dict, g_hash_table_unref);
|
|
|
|
nm_g_object_unref(get_config_data->intern_cancellable);
|
|
g_object_unref(get_config_data->task);
|
|
nm_g_slice_free(get_config_data);
|
|
}
|
|
|
|
void
|
|
_nmcs_provider_get_config_task_maybe_return(NMCSProviderGetConfigTaskData *get_config_data,
|
|
GError * error_take)
|
|
{
|
|
nm_assert(!error_take || !nm_utils_error_is_cancelled(error_take));
|
|
_get_config_task_maybe_return(get_config_data, error_take);
|
|
}
|
|
|
|
static void
|
|
_get_config_cancelled_cb(GObject *object, gpointer user_data)
|
|
{
|
|
_get_config_task_maybe_return(user_data, nm_utils_error_new_cancelled(FALSE, NULL));
|
|
}
|
|
|
|
void
|
|
nmcs_provider_get_config(NMCSProvider * self,
|
|
gboolean any,
|
|
const char *const * hwaddrs,
|
|
GCancellable * cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
NMCSProviderGetConfigTaskData *get_config_data;
|
|
|
|
g_return_if_fail(NMCS_IS_PROVIDER(self));
|
|
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
|
|
|
|
_LOGD("get-config: starting");
|
|
|
|
get_config_data = g_slice_new(NMCSProviderGetConfigTaskData);
|
|
*get_config_data = (NMCSProviderGetConfigTaskData){
|
|
.task = nm_g_task_new(self, cancellable, nmcs_provider_get_config, callback, user_data),
|
|
.any = any,
|
|
.result_dict = g_hash_table_new_full(nm_str_hash, g_str_equal, g_free, _iface_data_free),
|
|
};
|
|
|
|
nmcs_wait_for_objects_register(get_config_data->task);
|
|
|
|
for (; hwaddrs && hwaddrs[0]; hwaddrs++) {
|
|
g_hash_table_insert(get_config_data->result_dict,
|
|
g_strdup(hwaddrs[0]),
|
|
nmcs_provider_get_config_iface_data_new(TRUE));
|
|
}
|
|
|
|
if (cancellable) {
|
|
gulong cancelled_id;
|
|
|
|
cancelled_id = g_cancellable_connect(cancellable,
|
|
G_CALLBACK(_get_config_cancelled_cb),
|
|
get_config_data,
|
|
NULL);
|
|
if (cancelled_id == 0) {
|
|
/* the callback was already invoked synchronously and the task already returned. */
|
|
return;
|
|
}
|
|
|
|
get_config_data->extern_cancelled_id = cancelled_id;
|
|
get_config_data->intern_cancellable = g_cancellable_new();
|
|
}
|
|
|
|
NMCS_PROVIDER_GET_CLASS(self)->get_config(self, get_config_data);
|
|
}
|
|
|
|
GHashTable *
|
|
nmcs_provider_get_config_finish(NMCSProvider *self, GAsyncResult *result, GError **error)
|
|
{
|
|
g_return_val_if_fail(NMCS_IS_PROVIDER(self), FALSE);
|
|
g_return_val_if_fail(nm_g_task_is_valid(result, self, nmcs_provider_get_config), FALSE);
|
|
|
|
return g_task_propagate_pointer(G_TASK(result), error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMCSProviderPrivate *priv = NMCS_PROVIDER_GET_PRIVATE(object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_HTTP_CLIENT:
|
|
priv->http_client = g_value_dup_object(value);
|
|
g_return_if_fail(NM_IS_HTTP_CLIENT(priv->http_client));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
nmcs_provider_init(NMCSProvider *self)
|
|
{
|
|
NMCSProviderPrivate *priv;
|
|
|
|
priv = G_TYPE_INSTANCE_GET_PRIVATE(self, NMCS_TYPE_PROVIDER, NMCSProviderPrivate);
|
|
|
|
self->_priv = priv;
|
|
}
|
|
|
|
static void
|
|
dispose(GObject *object)
|
|
{
|
|
NMCSProvider * self = NMCS_PROVIDER(object);
|
|
NMCSProviderPrivate *priv = NMCS_PROVIDER_GET_PRIVATE(self);
|
|
|
|
g_clear_object(&priv->http_client);
|
|
|
|
G_OBJECT_CLASS(nmcs_provider_parent_class)->dispose(object);
|
|
}
|
|
|
|
static void
|
|
nmcs_provider_class_init(NMCSProviderClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS(klass);
|
|
|
|
g_type_class_add_private(object_class, sizeof(NMCSProviderPrivate));
|
|
|
|
object_class->set_property = set_property;
|
|
object_class->dispose = dispose;
|
|
|
|
obj_properties[PROP_HTTP_CLIENT] =
|
|
g_param_spec_object(NMCS_PROVIDER_HTTP_CLIENT,
|
|
"",
|
|
"",
|
|
NM_TYPE_HTTP_CLIENT,
|
|
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
|
|
}
|